1use crate::stream_plan::*;
2impl serde::Serialize for ActorMapping {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if !self.original_indices.is_empty() {
11 len += 1;
12 }
13 if !self.data.is_empty() {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
17 if !self.original_indices.is_empty() {
18 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
19 }
20 if !self.data.is_empty() {
21 struct_ser.serialize_field("data", &self.data)?;
22 }
23 struct_ser.end()
24 }
25}
26impl<'de> serde::Deserialize<'de> for ActorMapping {
27 #[allow(deprecated)]
28 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 const FIELDS: &[&str] = &[
33 "original_indices",
34 "originalIndices",
35 "data",
36 ];
37
38 #[allow(clippy::enum_variant_names)]
39 enum GeneratedField {
40 OriginalIndices,
41 Data,
42 }
43 impl<'de> serde::Deserialize<'de> for GeneratedField {
44 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45 where
46 D: serde::Deserializer<'de>,
47 {
48 struct GeneratedVisitor;
49
50 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51 type Value = GeneratedField;
52
53 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(formatter, "expected one of: {:?}", &FIELDS)
55 }
56
57 #[allow(unused_variables)]
58 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59 where
60 E: serde::de::Error,
61 {
62 match value {
63 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
64 "data" => Ok(GeneratedField::Data),
65 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66 }
67 }
68 }
69 deserializer.deserialize_identifier(GeneratedVisitor)
70 }
71 }
72 struct GeneratedVisitor;
73 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74 type Value = ActorMapping;
75
76 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 formatter.write_str("struct stream_plan.ActorMapping")
78 }
79
80 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
81 where
82 V: serde::de::MapAccess<'de>,
83 {
84 let mut original_indices__ = None;
85 let mut data__ = None;
86 while let Some(k) = map_.next_key()? {
87 match k {
88 GeneratedField::OriginalIndices => {
89 if original_indices__.is_some() {
90 return Err(serde::de::Error::duplicate_field("originalIndices"));
91 }
92 original_indices__ =
93 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
94 .into_iter().map(|x| x.0).collect())
95 ;
96 }
97 GeneratedField::Data => {
98 if data__.is_some() {
99 return Err(serde::de::Error::duplicate_field("data"));
100 }
101 data__ =
102 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
103 .into_iter().map(|x| x.0).collect())
104 ;
105 }
106 }
107 }
108 Ok(ActorMapping {
109 original_indices: original_indices__.unwrap_or_default(),
110 data: data__.unwrap_or_default(),
111 })
112 }
113 }
114 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
115 }
116}
117impl serde::Serialize for AddMutation {
118 #[allow(deprecated)]
119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
120 where
121 S: serde::Serializer,
122 {
123 use serde::ser::SerializeStruct;
124 let mut len = 0;
125 if !self.actor_dispatchers.is_empty() {
126 len += 1;
127 }
128 if !self.added_actors.is_empty() {
129 len += 1;
130 }
131 if !self.actor_splits.is_empty() {
132 len += 1;
133 }
134 if self.pause {
135 len += 1;
136 }
137 if !self.subscriptions_to_add.is_empty() {
138 len += 1;
139 }
140 if !self.backfill_nodes_to_pause.is_empty() {
141 len += 1;
142 }
143 if !self.actor_cdc_table_snapshot_splits.is_empty() {
144 len += 1;
145 }
146 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
147 if !self.actor_dispatchers.is_empty() {
148 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
149 }
150 if !self.added_actors.is_empty() {
151 struct_ser.serialize_field("addedActors", &self.added_actors)?;
152 }
153 if !self.actor_splits.is_empty() {
154 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
155 }
156 if self.pause {
157 struct_ser.serialize_field("pause", &self.pause)?;
158 }
159 if !self.subscriptions_to_add.is_empty() {
160 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
161 }
162 if !self.backfill_nodes_to_pause.is_empty() {
163 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
164 }
165 if !self.actor_cdc_table_snapshot_splits.is_empty() {
166 struct_ser.serialize_field("actorCdcTableSnapshotSplits", &self.actor_cdc_table_snapshot_splits)?;
167 }
168 struct_ser.end()
169 }
170}
171impl<'de> serde::Deserialize<'de> for AddMutation {
172 #[allow(deprecated)]
173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
174 where
175 D: serde::Deserializer<'de>,
176 {
177 const FIELDS: &[&str] = &[
178 "actor_dispatchers",
179 "actorDispatchers",
180 "added_actors",
181 "addedActors",
182 "actor_splits",
183 "actorSplits",
184 "pause",
185 "subscriptions_to_add",
186 "subscriptionsToAdd",
187 "backfill_nodes_to_pause",
188 "backfillNodesToPause",
189 "actor_cdc_table_snapshot_splits",
190 "actorCdcTableSnapshotSplits",
191 ];
192
193 #[allow(clippy::enum_variant_names)]
194 enum GeneratedField {
195 ActorDispatchers,
196 AddedActors,
197 ActorSplits,
198 Pause,
199 SubscriptionsToAdd,
200 BackfillNodesToPause,
201 ActorCdcTableSnapshotSplits,
202 }
203 impl<'de> serde::Deserialize<'de> for GeneratedField {
204 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
205 where
206 D: serde::Deserializer<'de>,
207 {
208 struct GeneratedVisitor;
209
210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
211 type Value = GeneratedField;
212
213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
214 write!(formatter, "expected one of: {:?}", &FIELDS)
215 }
216
217 #[allow(unused_variables)]
218 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
219 where
220 E: serde::de::Error,
221 {
222 match value {
223 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
224 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
225 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
226 "pause" => Ok(GeneratedField::Pause),
227 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
228 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
229 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
230 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
231 }
232 }
233 }
234 deserializer.deserialize_identifier(GeneratedVisitor)
235 }
236 }
237 struct GeneratedVisitor;
238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
239 type Value = AddMutation;
240
241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
242 formatter.write_str("struct stream_plan.AddMutation")
243 }
244
245 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
246 where
247 V: serde::de::MapAccess<'de>,
248 {
249 let mut actor_dispatchers__ = None;
250 let mut added_actors__ = None;
251 let mut actor_splits__ = None;
252 let mut pause__ = None;
253 let mut subscriptions_to_add__ = None;
254 let mut backfill_nodes_to_pause__ = None;
255 let mut actor_cdc_table_snapshot_splits__ = None;
256 while let Some(k) = map_.next_key()? {
257 match k {
258 GeneratedField::ActorDispatchers => {
259 if actor_dispatchers__.is_some() {
260 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
261 }
262 actor_dispatchers__ = Some(
263 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
264 .into_iter().map(|(k,v)| (k.0, v)).collect()
265 );
266 }
267 GeneratedField::AddedActors => {
268 if added_actors__.is_some() {
269 return Err(serde::de::Error::duplicate_field("addedActors"));
270 }
271 added_actors__ =
272 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
273 .into_iter().map(|x| x.0).collect())
274 ;
275 }
276 GeneratedField::ActorSplits => {
277 if actor_splits__.is_some() {
278 return Err(serde::de::Error::duplicate_field("actorSplits"));
279 }
280 actor_splits__ = Some(
281 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
282 .into_iter().map(|(k,v)| (k.0, v)).collect()
283 );
284 }
285 GeneratedField::Pause => {
286 if pause__.is_some() {
287 return Err(serde::de::Error::duplicate_field("pause"));
288 }
289 pause__ = Some(map_.next_value()?);
290 }
291 GeneratedField::SubscriptionsToAdd => {
292 if subscriptions_to_add__.is_some() {
293 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
294 }
295 subscriptions_to_add__ = Some(map_.next_value()?);
296 }
297 GeneratedField::BackfillNodesToPause => {
298 if backfill_nodes_to_pause__.is_some() {
299 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
300 }
301 backfill_nodes_to_pause__ =
302 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
303 .into_iter().map(|x| x.0).collect())
304 ;
305 }
306 GeneratedField::ActorCdcTableSnapshotSplits => {
307 if actor_cdc_table_snapshot_splits__.is_some() {
308 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
309 }
310 actor_cdc_table_snapshot_splits__ = Some(
311 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
312 .into_iter().map(|(k,v)| (k.0, v)).collect()
313 );
314 }
315 }
316 }
317 Ok(AddMutation {
318 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
319 added_actors: added_actors__.unwrap_or_default(),
320 actor_splits: actor_splits__.unwrap_or_default(),
321 pause: pause__.unwrap_or_default(),
322 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
323 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
324 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__.unwrap_or_default(),
325 })
326 }
327 }
328 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
329 }
330}
331impl serde::Serialize for AggCallState {
332 #[allow(deprecated)]
333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
334 where
335 S: serde::Serializer,
336 {
337 use serde::ser::SerializeStruct;
338 let mut len = 0;
339 if self.inner.is_some() {
340 len += 1;
341 }
342 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
343 if let Some(v) = self.inner.as_ref() {
344 match v {
345 agg_call_state::Inner::ValueState(v) => {
346 struct_ser.serialize_field("valueState", v)?;
347 }
348 agg_call_state::Inner::MaterializedInputState(v) => {
349 struct_ser.serialize_field("materializedInputState", v)?;
350 }
351 }
352 }
353 struct_ser.end()
354 }
355}
356impl<'de> serde::Deserialize<'de> for AggCallState {
357 #[allow(deprecated)]
358 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
359 where
360 D: serde::Deserializer<'de>,
361 {
362 const FIELDS: &[&str] = &[
363 "value_state",
364 "valueState",
365 "materialized_input_state",
366 "materializedInputState",
367 ];
368
369 #[allow(clippy::enum_variant_names)]
370 enum GeneratedField {
371 ValueState,
372 MaterializedInputState,
373 }
374 impl<'de> serde::Deserialize<'de> for GeneratedField {
375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
376 where
377 D: serde::Deserializer<'de>,
378 {
379 struct GeneratedVisitor;
380
381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
382 type Value = GeneratedField;
383
384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
385 write!(formatter, "expected one of: {:?}", &FIELDS)
386 }
387
388 #[allow(unused_variables)]
389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
390 where
391 E: serde::de::Error,
392 {
393 match value {
394 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
395 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
396 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
397 }
398 }
399 }
400 deserializer.deserialize_identifier(GeneratedVisitor)
401 }
402 }
403 struct GeneratedVisitor;
404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
405 type Value = AggCallState;
406
407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
408 formatter.write_str("struct stream_plan.AggCallState")
409 }
410
411 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
412 where
413 V: serde::de::MapAccess<'de>,
414 {
415 let mut inner__ = None;
416 while let Some(k) = map_.next_key()? {
417 match k {
418 GeneratedField::ValueState => {
419 if inner__.is_some() {
420 return Err(serde::de::Error::duplicate_field("valueState"));
421 }
422 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
423;
424 }
425 GeneratedField::MaterializedInputState => {
426 if inner__.is_some() {
427 return Err(serde::de::Error::duplicate_field("materializedInputState"));
428 }
429 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
430;
431 }
432 }
433 }
434 Ok(AggCallState {
435 inner: inner__,
436 })
437 }
438 }
439 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
440 }
441}
442impl serde::Serialize for agg_call_state::MaterializedInputState {
443 #[allow(deprecated)]
444 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
445 where
446 S: serde::Serializer,
447 {
448 use serde::ser::SerializeStruct;
449 let mut len = 0;
450 if self.table.is_some() {
451 len += 1;
452 }
453 if !self.included_upstream_indices.is_empty() {
454 len += 1;
455 }
456 if !self.table_value_indices.is_empty() {
457 len += 1;
458 }
459 if !self.order_columns.is_empty() {
460 len += 1;
461 }
462 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
463 if let Some(v) = self.table.as_ref() {
464 struct_ser.serialize_field("table", v)?;
465 }
466 if !self.included_upstream_indices.is_empty() {
467 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
468 }
469 if !self.table_value_indices.is_empty() {
470 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
471 }
472 if !self.order_columns.is_empty() {
473 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
474 }
475 struct_ser.end()
476 }
477}
478impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
479 #[allow(deprecated)]
480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
481 where
482 D: serde::Deserializer<'de>,
483 {
484 const FIELDS: &[&str] = &[
485 "table",
486 "included_upstream_indices",
487 "includedUpstreamIndices",
488 "table_value_indices",
489 "tableValueIndices",
490 "order_columns",
491 "orderColumns",
492 ];
493
494 #[allow(clippy::enum_variant_names)]
495 enum GeneratedField {
496 Table,
497 IncludedUpstreamIndices,
498 TableValueIndices,
499 OrderColumns,
500 }
501 impl<'de> serde::Deserialize<'de> for GeneratedField {
502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
503 where
504 D: serde::Deserializer<'de>,
505 {
506 struct GeneratedVisitor;
507
508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
509 type Value = GeneratedField;
510
511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
512 write!(formatter, "expected one of: {:?}", &FIELDS)
513 }
514
515 #[allow(unused_variables)]
516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
517 where
518 E: serde::de::Error,
519 {
520 match value {
521 "table" => Ok(GeneratedField::Table),
522 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
523 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
524 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
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 = agg_call_state::MaterializedInputState;
535
536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
537 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
538 }
539
540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
541 where
542 V: serde::de::MapAccess<'de>,
543 {
544 let mut table__ = None;
545 let mut included_upstream_indices__ = None;
546 let mut table_value_indices__ = None;
547 let mut order_columns__ = None;
548 while let Some(k) = map_.next_key()? {
549 match k {
550 GeneratedField::Table => {
551 if table__.is_some() {
552 return Err(serde::de::Error::duplicate_field("table"));
553 }
554 table__ = map_.next_value()?;
555 }
556 GeneratedField::IncludedUpstreamIndices => {
557 if included_upstream_indices__.is_some() {
558 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
559 }
560 included_upstream_indices__ =
561 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
562 .into_iter().map(|x| x.0).collect())
563 ;
564 }
565 GeneratedField::TableValueIndices => {
566 if table_value_indices__.is_some() {
567 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
568 }
569 table_value_indices__ =
570 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
571 .into_iter().map(|x| x.0).collect())
572 ;
573 }
574 GeneratedField::OrderColumns => {
575 if order_columns__.is_some() {
576 return Err(serde::de::Error::duplicate_field("orderColumns"));
577 }
578 order_columns__ = Some(map_.next_value()?);
579 }
580 }
581 }
582 Ok(agg_call_state::MaterializedInputState {
583 table: table__,
584 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
585 table_value_indices: table_value_indices__.unwrap_or_default(),
586 order_columns: order_columns__.unwrap_or_default(),
587 })
588 }
589 }
590 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
591 }
592}
593impl serde::Serialize for agg_call_state::ValueState {
594 #[allow(deprecated)]
595 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
596 where
597 S: serde::Serializer,
598 {
599 use serde::ser::SerializeStruct;
600 let len = 0;
601 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
602 struct_ser.end()
603 }
604}
605impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
606 #[allow(deprecated)]
607 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
608 where
609 D: serde::Deserializer<'de>,
610 {
611 const FIELDS: &[&str] = &[
612 ];
613
614 #[allow(clippy::enum_variant_names)]
615 enum GeneratedField {
616 }
617 impl<'de> serde::Deserialize<'de> for GeneratedField {
618 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
619 where
620 D: serde::Deserializer<'de>,
621 {
622 struct GeneratedVisitor;
623
624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
625 type Value = GeneratedField;
626
627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
628 write!(formatter, "expected one of: {:?}", &FIELDS)
629 }
630
631 #[allow(unused_variables)]
632 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
633 where
634 E: serde::de::Error,
635 {
636 Err(serde::de::Error::unknown_field(value, FIELDS))
637 }
638 }
639 deserializer.deserialize_identifier(GeneratedVisitor)
640 }
641 }
642 struct GeneratedVisitor;
643 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
644 type Value = agg_call_state::ValueState;
645
646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
647 formatter.write_str("struct stream_plan.AggCallState.ValueState")
648 }
649
650 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
651 where
652 V: serde::de::MapAccess<'de>,
653 {
654 while map_.next_key::<GeneratedField>()?.is_some() {
655 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
656 }
657 Ok(agg_call_state::ValueState {
658 })
659 }
660 }
661 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
662 }
663}
664impl serde::Serialize for AggNodeVersion {
665 #[allow(deprecated)]
666 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
667 where
668 S: serde::Serializer,
669 {
670 let variant = match self {
671 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
672 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
673 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
674 };
675 serializer.serialize_str(variant)
676 }
677}
678impl<'de> serde::Deserialize<'de> for AggNodeVersion {
679 #[allow(deprecated)]
680 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
681 where
682 D: serde::Deserializer<'de>,
683 {
684 const FIELDS: &[&str] = &[
685 "AGG_NODE_VERSION_UNSPECIFIED",
686 "AGG_NODE_VERSION_ISSUE_12140",
687 "AGG_NODE_VERSION_ISSUE_13465",
688 ];
689
690 struct GeneratedVisitor;
691
692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
693 type Value = AggNodeVersion;
694
695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
696 write!(formatter, "expected one of: {:?}", &FIELDS)
697 }
698
699 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
700 where
701 E: serde::de::Error,
702 {
703 i32::try_from(v)
704 .ok()
705 .and_then(|x| x.try_into().ok())
706 .ok_or_else(|| {
707 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
708 })
709 }
710
711 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
712 where
713 E: serde::de::Error,
714 {
715 i32::try_from(v)
716 .ok()
717 .and_then(|x| x.try_into().ok())
718 .ok_or_else(|| {
719 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
720 })
721 }
722
723 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
724 where
725 E: serde::de::Error,
726 {
727 match value {
728 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
729 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
730 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
731 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
732 }
733 }
734 }
735 deserializer.deserialize_any(GeneratedVisitor)
736 }
737}
738impl serde::Serialize for ArrangeNode {
739 #[allow(deprecated)]
740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
741 where
742 S: serde::Serializer,
743 {
744 use serde::ser::SerializeStruct;
745 let mut len = 0;
746 if self.table_info.is_some() {
747 len += 1;
748 }
749 if !self.distribution_key.is_empty() {
750 len += 1;
751 }
752 if self.table.is_some() {
753 len += 1;
754 }
755 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
756 if let Some(v) = self.table_info.as_ref() {
757 struct_ser.serialize_field("tableInfo", v)?;
758 }
759 if !self.distribution_key.is_empty() {
760 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
761 }
762 if let Some(v) = self.table.as_ref() {
763 struct_ser.serialize_field("table", v)?;
764 }
765 struct_ser.end()
766 }
767}
768impl<'de> serde::Deserialize<'de> for ArrangeNode {
769 #[allow(deprecated)]
770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
771 where
772 D: serde::Deserializer<'de>,
773 {
774 const FIELDS: &[&str] = &[
775 "table_info",
776 "tableInfo",
777 "distribution_key",
778 "distributionKey",
779 "table",
780 ];
781
782 #[allow(clippy::enum_variant_names)]
783 enum GeneratedField {
784 TableInfo,
785 DistributionKey,
786 Table,
787 }
788 impl<'de> serde::Deserialize<'de> for GeneratedField {
789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
790 where
791 D: serde::Deserializer<'de>,
792 {
793 struct GeneratedVisitor;
794
795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
796 type Value = GeneratedField;
797
798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
799 write!(formatter, "expected one of: {:?}", &FIELDS)
800 }
801
802 #[allow(unused_variables)]
803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
804 where
805 E: serde::de::Error,
806 {
807 match value {
808 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
809 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
810 "table" => Ok(GeneratedField::Table),
811 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
812 }
813 }
814 }
815 deserializer.deserialize_identifier(GeneratedVisitor)
816 }
817 }
818 struct GeneratedVisitor;
819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
820 type Value = ArrangeNode;
821
822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
823 formatter.write_str("struct stream_plan.ArrangeNode")
824 }
825
826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
827 where
828 V: serde::de::MapAccess<'de>,
829 {
830 let mut table_info__ = None;
831 let mut distribution_key__ = None;
832 let mut table__ = None;
833 while let Some(k) = map_.next_key()? {
834 match k {
835 GeneratedField::TableInfo => {
836 if table_info__.is_some() {
837 return Err(serde::de::Error::duplicate_field("tableInfo"));
838 }
839 table_info__ = map_.next_value()?;
840 }
841 GeneratedField::DistributionKey => {
842 if distribution_key__.is_some() {
843 return Err(serde::de::Error::duplicate_field("distributionKey"));
844 }
845 distribution_key__ =
846 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
847 .into_iter().map(|x| x.0).collect())
848 ;
849 }
850 GeneratedField::Table => {
851 if table__.is_some() {
852 return Err(serde::de::Error::duplicate_field("table"));
853 }
854 table__ = map_.next_value()?;
855 }
856 }
857 }
858 Ok(ArrangeNode {
859 table_info: table_info__,
860 distribution_key: distribution_key__.unwrap_or_default(),
861 table: table__,
862 })
863 }
864 }
865 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
866 }
867}
868impl serde::Serialize for ArrangementInfo {
869 #[allow(deprecated)]
870 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
871 where
872 S: serde::Serializer,
873 {
874 use serde::ser::SerializeStruct;
875 let mut len = 0;
876 if !self.arrange_key_orders.is_empty() {
877 len += 1;
878 }
879 if !self.column_descs.is_empty() {
880 len += 1;
881 }
882 if self.table_desc.is_some() {
883 len += 1;
884 }
885 if !self.output_col_idx.is_empty() {
886 len += 1;
887 }
888 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
889 if !self.arrange_key_orders.is_empty() {
890 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
891 }
892 if !self.column_descs.is_empty() {
893 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
894 }
895 if let Some(v) = self.table_desc.as_ref() {
896 struct_ser.serialize_field("tableDesc", v)?;
897 }
898 if !self.output_col_idx.is_empty() {
899 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
900 }
901 struct_ser.end()
902 }
903}
904impl<'de> serde::Deserialize<'de> for ArrangementInfo {
905 #[allow(deprecated)]
906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
907 where
908 D: serde::Deserializer<'de>,
909 {
910 const FIELDS: &[&str] = &[
911 "arrange_key_orders",
912 "arrangeKeyOrders",
913 "column_descs",
914 "columnDescs",
915 "table_desc",
916 "tableDesc",
917 "output_col_idx",
918 "outputColIdx",
919 ];
920
921 #[allow(clippy::enum_variant_names)]
922 enum GeneratedField {
923 ArrangeKeyOrders,
924 ColumnDescs,
925 TableDesc,
926 OutputColIdx,
927 }
928 impl<'de> serde::Deserialize<'de> for GeneratedField {
929 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
930 where
931 D: serde::Deserializer<'de>,
932 {
933 struct GeneratedVisitor;
934
935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
936 type Value = GeneratedField;
937
938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
939 write!(formatter, "expected one of: {:?}", &FIELDS)
940 }
941
942 #[allow(unused_variables)]
943 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
944 where
945 E: serde::de::Error,
946 {
947 match value {
948 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
949 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
950 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
951 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
952 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
953 }
954 }
955 }
956 deserializer.deserialize_identifier(GeneratedVisitor)
957 }
958 }
959 struct GeneratedVisitor;
960 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
961 type Value = ArrangementInfo;
962
963 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
964 formatter.write_str("struct stream_plan.ArrangementInfo")
965 }
966
967 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
968 where
969 V: serde::de::MapAccess<'de>,
970 {
971 let mut arrange_key_orders__ = None;
972 let mut column_descs__ = None;
973 let mut table_desc__ = None;
974 let mut output_col_idx__ = None;
975 while let Some(k) = map_.next_key()? {
976 match k {
977 GeneratedField::ArrangeKeyOrders => {
978 if arrange_key_orders__.is_some() {
979 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
980 }
981 arrange_key_orders__ = Some(map_.next_value()?);
982 }
983 GeneratedField::ColumnDescs => {
984 if column_descs__.is_some() {
985 return Err(serde::de::Error::duplicate_field("columnDescs"));
986 }
987 column_descs__ = Some(map_.next_value()?);
988 }
989 GeneratedField::TableDesc => {
990 if table_desc__.is_some() {
991 return Err(serde::de::Error::duplicate_field("tableDesc"));
992 }
993 table_desc__ = map_.next_value()?;
994 }
995 GeneratedField::OutputColIdx => {
996 if output_col_idx__.is_some() {
997 return Err(serde::de::Error::duplicate_field("outputColIdx"));
998 }
999 output_col_idx__ =
1000 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1001 .into_iter().map(|x| x.0).collect())
1002 ;
1003 }
1004 }
1005 }
1006 Ok(ArrangementInfo {
1007 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1008 column_descs: column_descs__.unwrap_or_default(),
1009 table_desc: table_desc__,
1010 output_col_idx: output_col_idx__.unwrap_or_default(),
1011 })
1012 }
1013 }
1014 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1015 }
1016}
1017impl serde::Serialize for AsOfJoinNode {
1018 #[allow(deprecated)]
1019 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1020 where
1021 S: serde::Serializer,
1022 {
1023 use serde::ser::SerializeStruct;
1024 let mut len = 0;
1025 if self.join_type != 0 {
1026 len += 1;
1027 }
1028 if !self.left_key.is_empty() {
1029 len += 1;
1030 }
1031 if !self.right_key.is_empty() {
1032 len += 1;
1033 }
1034 if self.left_table.is_some() {
1035 len += 1;
1036 }
1037 if self.right_table.is_some() {
1038 len += 1;
1039 }
1040 if !self.output_indices.is_empty() {
1041 len += 1;
1042 }
1043 if !self.left_deduped_input_pk_indices.is_empty() {
1044 len += 1;
1045 }
1046 if !self.right_deduped_input_pk_indices.is_empty() {
1047 len += 1;
1048 }
1049 if !self.null_safe.is_empty() {
1050 len += 1;
1051 }
1052 if self.asof_desc.is_some() {
1053 len += 1;
1054 }
1055 if self.join_encoding_type != 0 {
1056 len += 1;
1057 }
1058 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1059 if self.join_type != 0 {
1060 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1061 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1062 struct_ser.serialize_field("joinType", &v)?;
1063 }
1064 if !self.left_key.is_empty() {
1065 struct_ser.serialize_field("leftKey", &self.left_key)?;
1066 }
1067 if !self.right_key.is_empty() {
1068 struct_ser.serialize_field("rightKey", &self.right_key)?;
1069 }
1070 if let Some(v) = self.left_table.as_ref() {
1071 struct_ser.serialize_field("leftTable", v)?;
1072 }
1073 if let Some(v) = self.right_table.as_ref() {
1074 struct_ser.serialize_field("rightTable", v)?;
1075 }
1076 if !self.output_indices.is_empty() {
1077 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1078 }
1079 if !self.left_deduped_input_pk_indices.is_empty() {
1080 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1081 }
1082 if !self.right_deduped_input_pk_indices.is_empty() {
1083 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1084 }
1085 if !self.null_safe.is_empty() {
1086 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1087 }
1088 if let Some(v) = self.asof_desc.as_ref() {
1089 struct_ser.serialize_field("asofDesc", v)?;
1090 }
1091 if self.join_encoding_type != 0 {
1092 let v = JoinEncodingType::try_from(self.join_encoding_type)
1093 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1094 struct_ser.serialize_field("joinEncodingType", &v)?;
1095 }
1096 struct_ser.end()
1097 }
1098}
1099impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1100 #[allow(deprecated)]
1101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1102 where
1103 D: serde::Deserializer<'de>,
1104 {
1105 const FIELDS: &[&str] = &[
1106 "join_type",
1107 "joinType",
1108 "left_key",
1109 "leftKey",
1110 "right_key",
1111 "rightKey",
1112 "left_table",
1113 "leftTable",
1114 "right_table",
1115 "rightTable",
1116 "output_indices",
1117 "outputIndices",
1118 "left_deduped_input_pk_indices",
1119 "leftDedupedInputPkIndices",
1120 "right_deduped_input_pk_indices",
1121 "rightDedupedInputPkIndices",
1122 "null_safe",
1123 "nullSafe",
1124 "asof_desc",
1125 "asofDesc",
1126 "join_encoding_type",
1127 "joinEncodingType",
1128 ];
1129
1130 #[allow(clippy::enum_variant_names)]
1131 enum GeneratedField {
1132 JoinType,
1133 LeftKey,
1134 RightKey,
1135 LeftTable,
1136 RightTable,
1137 OutputIndices,
1138 LeftDedupedInputPkIndices,
1139 RightDedupedInputPkIndices,
1140 NullSafe,
1141 AsofDesc,
1142 JoinEncodingType,
1143 }
1144 impl<'de> serde::Deserialize<'de> for GeneratedField {
1145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1146 where
1147 D: serde::Deserializer<'de>,
1148 {
1149 struct GeneratedVisitor;
1150
1151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1152 type Value = GeneratedField;
1153
1154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1155 write!(formatter, "expected one of: {:?}", &FIELDS)
1156 }
1157
1158 #[allow(unused_variables)]
1159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1160 where
1161 E: serde::de::Error,
1162 {
1163 match value {
1164 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1165 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1166 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1167 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1168 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1169 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1170 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1171 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1172 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1173 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1174 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1175 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1176 }
1177 }
1178 }
1179 deserializer.deserialize_identifier(GeneratedVisitor)
1180 }
1181 }
1182 struct GeneratedVisitor;
1183 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1184 type Value = AsOfJoinNode;
1185
1186 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1187 formatter.write_str("struct stream_plan.AsOfJoinNode")
1188 }
1189
1190 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1191 where
1192 V: serde::de::MapAccess<'de>,
1193 {
1194 let mut join_type__ = None;
1195 let mut left_key__ = None;
1196 let mut right_key__ = None;
1197 let mut left_table__ = None;
1198 let mut right_table__ = None;
1199 let mut output_indices__ = None;
1200 let mut left_deduped_input_pk_indices__ = None;
1201 let mut right_deduped_input_pk_indices__ = None;
1202 let mut null_safe__ = None;
1203 let mut asof_desc__ = None;
1204 let mut join_encoding_type__ = None;
1205 while let Some(k) = map_.next_key()? {
1206 match k {
1207 GeneratedField::JoinType => {
1208 if join_type__.is_some() {
1209 return Err(serde::de::Error::duplicate_field("joinType"));
1210 }
1211 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1212 }
1213 GeneratedField::LeftKey => {
1214 if left_key__.is_some() {
1215 return Err(serde::de::Error::duplicate_field("leftKey"));
1216 }
1217 left_key__ =
1218 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1219 .into_iter().map(|x| x.0).collect())
1220 ;
1221 }
1222 GeneratedField::RightKey => {
1223 if right_key__.is_some() {
1224 return Err(serde::de::Error::duplicate_field("rightKey"));
1225 }
1226 right_key__ =
1227 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1228 .into_iter().map(|x| x.0).collect())
1229 ;
1230 }
1231 GeneratedField::LeftTable => {
1232 if left_table__.is_some() {
1233 return Err(serde::de::Error::duplicate_field("leftTable"));
1234 }
1235 left_table__ = map_.next_value()?;
1236 }
1237 GeneratedField::RightTable => {
1238 if right_table__.is_some() {
1239 return Err(serde::de::Error::duplicate_field("rightTable"));
1240 }
1241 right_table__ = map_.next_value()?;
1242 }
1243 GeneratedField::OutputIndices => {
1244 if output_indices__.is_some() {
1245 return Err(serde::de::Error::duplicate_field("outputIndices"));
1246 }
1247 output_indices__ =
1248 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1249 .into_iter().map(|x| x.0).collect())
1250 ;
1251 }
1252 GeneratedField::LeftDedupedInputPkIndices => {
1253 if left_deduped_input_pk_indices__.is_some() {
1254 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1255 }
1256 left_deduped_input_pk_indices__ =
1257 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1258 .into_iter().map(|x| x.0).collect())
1259 ;
1260 }
1261 GeneratedField::RightDedupedInputPkIndices => {
1262 if right_deduped_input_pk_indices__.is_some() {
1263 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1264 }
1265 right_deduped_input_pk_indices__ =
1266 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1267 .into_iter().map(|x| x.0).collect())
1268 ;
1269 }
1270 GeneratedField::NullSafe => {
1271 if null_safe__.is_some() {
1272 return Err(serde::de::Error::duplicate_field("nullSafe"));
1273 }
1274 null_safe__ = Some(map_.next_value()?);
1275 }
1276 GeneratedField::AsofDesc => {
1277 if asof_desc__.is_some() {
1278 return Err(serde::de::Error::duplicate_field("asofDesc"));
1279 }
1280 asof_desc__ = map_.next_value()?;
1281 }
1282 GeneratedField::JoinEncodingType => {
1283 if join_encoding_type__.is_some() {
1284 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1285 }
1286 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1287 }
1288 }
1289 }
1290 Ok(AsOfJoinNode {
1291 join_type: join_type__.unwrap_or_default(),
1292 left_key: left_key__.unwrap_or_default(),
1293 right_key: right_key__.unwrap_or_default(),
1294 left_table: left_table__,
1295 right_table: right_table__,
1296 output_indices: output_indices__.unwrap_or_default(),
1297 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1298 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1299 null_safe: null_safe__.unwrap_or_default(),
1300 asof_desc: asof_desc__,
1301 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1302 })
1303 }
1304 }
1305 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1306 }
1307}
1308impl serde::Serialize for BackfillOrder {
1309 #[allow(deprecated)]
1310 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1311 where
1312 S: serde::Serializer,
1313 {
1314 use serde::ser::SerializeStruct;
1315 let mut len = 0;
1316 if !self.order.is_empty() {
1317 len += 1;
1318 }
1319 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1320 if !self.order.is_empty() {
1321 struct_ser.serialize_field("order", &self.order)?;
1322 }
1323 struct_ser.end()
1324 }
1325}
1326impl<'de> serde::Deserialize<'de> for BackfillOrder {
1327 #[allow(deprecated)]
1328 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1329 where
1330 D: serde::Deserializer<'de>,
1331 {
1332 const FIELDS: &[&str] = &[
1333 "order",
1334 ];
1335
1336 #[allow(clippy::enum_variant_names)]
1337 enum GeneratedField {
1338 Order,
1339 }
1340 impl<'de> serde::Deserialize<'de> for GeneratedField {
1341 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1342 where
1343 D: serde::Deserializer<'de>,
1344 {
1345 struct GeneratedVisitor;
1346
1347 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1348 type Value = GeneratedField;
1349
1350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1351 write!(formatter, "expected one of: {:?}", &FIELDS)
1352 }
1353
1354 #[allow(unused_variables)]
1355 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1356 where
1357 E: serde::de::Error,
1358 {
1359 match value {
1360 "order" => Ok(GeneratedField::Order),
1361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1362 }
1363 }
1364 }
1365 deserializer.deserialize_identifier(GeneratedVisitor)
1366 }
1367 }
1368 struct GeneratedVisitor;
1369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1370 type Value = BackfillOrder;
1371
1372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1373 formatter.write_str("struct stream_plan.BackfillOrder")
1374 }
1375
1376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1377 where
1378 V: serde::de::MapAccess<'de>,
1379 {
1380 let mut order__ = None;
1381 while let Some(k) = map_.next_key()? {
1382 match k {
1383 GeneratedField::Order => {
1384 if order__.is_some() {
1385 return Err(serde::de::Error::duplicate_field("order"));
1386 }
1387 order__ = Some(
1388 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1389 .into_iter().map(|(k,v)| (k.0, v)).collect()
1390 );
1391 }
1392 }
1393 }
1394 Ok(BackfillOrder {
1395 order: order__.unwrap_or_default(),
1396 })
1397 }
1398 }
1399 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1400 }
1401}
1402impl serde::Serialize for Barrier {
1403 #[allow(deprecated)]
1404 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1405 where
1406 S: serde::Serializer,
1407 {
1408 use serde::ser::SerializeStruct;
1409 let mut len = 0;
1410 if self.epoch.is_some() {
1411 len += 1;
1412 }
1413 if self.mutation.is_some() {
1414 len += 1;
1415 }
1416 if !self.tracing_context.is_empty() {
1417 len += 1;
1418 }
1419 if self.kind != 0 {
1420 len += 1;
1421 }
1422 if !self.passed_actors.is_empty() {
1423 len += 1;
1424 }
1425 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1426 if let Some(v) = self.epoch.as_ref() {
1427 struct_ser.serialize_field("epoch", v)?;
1428 }
1429 if let Some(v) = self.mutation.as_ref() {
1430 struct_ser.serialize_field("mutation", v)?;
1431 }
1432 if !self.tracing_context.is_empty() {
1433 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1434 }
1435 if self.kind != 0 {
1436 let v = barrier::BarrierKind::try_from(self.kind)
1437 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1438 struct_ser.serialize_field("kind", &v)?;
1439 }
1440 if !self.passed_actors.is_empty() {
1441 struct_ser.serialize_field("passedActors", &self.passed_actors)?;
1442 }
1443 struct_ser.end()
1444 }
1445}
1446impl<'de> serde::Deserialize<'de> for Barrier {
1447 #[allow(deprecated)]
1448 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1449 where
1450 D: serde::Deserializer<'de>,
1451 {
1452 const FIELDS: &[&str] = &[
1453 "epoch",
1454 "mutation",
1455 "tracing_context",
1456 "tracingContext",
1457 "kind",
1458 "passed_actors",
1459 "passedActors",
1460 ];
1461
1462 #[allow(clippy::enum_variant_names)]
1463 enum GeneratedField {
1464 Epoch,
1465 Mutation,
1466 TracingContext,
1467 Kind,
1468 PassedActors,
1469 }
1470 impl<'de> serde::Deserialize<'de> for GeneratedField {
1471 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1472 where
1473 D: serde::Deserializer<'de>,
1474 {
1475 struct GeneratedVisitor;
1476
1477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1478 type Value = GeneratedField;
1479
1480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1481 write!(formatter, "expected one of: {:?}", &FIELDS)
1482 }
1483
1484 #[allow(unused_variables)]
1485 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1486 where
1487 E: serde::de::Error,
1488 {
1489 match value {
1490 "epoch" => Ok(GeneratedField::Epoch),
1491 "mutation" => Ok(GeneratedField::Mutation),
1492 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1493 "kind" => Ok(GeneratedField::Kind),
1494 "passedActors" | "passed_actors" => Ok(GeneratedField::PassedActors),
1495 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1496 }
1497 }
1498 }
1499 deserializer.deserialize_identifier(GeneratedVisitor)
1500 }
1501 }
1502 struct GeneratedVisitor;
1503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1504 type Value = Barrier;
1505
1506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1507 formatter.write_str("struct stream_plan.Barrier")
1508 }
1509
1510 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1511 where
1512 V: serde::de::MapAccess<'de>,
1513 {
1514 let mut epoch__ = None;
1515 let mut mutation__ = None;
1516 let mut tracing_context__ = None;
1517 let mut kind__ = None;
1518 let mut passed_actors__ = None;
1519 while let Some(k) = map_.next_key()? {
1520 match k {
1521 GeneratedField::Epoch => {
1522 if epoch__.is_some() {
1523 return Err(serde::de::Error::duplicate_field("epoch"));
1524 }
1525 epoch__ = map_.next_value()?;
1526 }
1527 GeneratedField::Mutation => {
1528 if mutation__.is_some() {
1529 return Err(serde::de::Error::duplicate_field("mutation"));
1530 }
1531 mutation__ = map_.next_value()?;
1532 }
1533 GeneratedField::TracingContext => {
1534 if tracing_context__.is_some() {
1535 return Err(serde::de::Error::duplicate_field("tracingContext"));
1536 }
1537 tracing_context__ = Some(
1538 map_.next_value::<std::collections::HashMap<_, _>>()?
1539 );
1540 }
1541 GeneratedField::Kind => {
1542 if kind__.is_some() {
1543 return Err(serde::de::Error::duplicate_field("kind"));
1544 }
1545 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1546 }
1547 GeneratedField::PassedActors => {
1548 if passed_actors__.is_some() {
1549 return Err(serde::de::Error::duplicate_field("passedActors"));
1550 }
1551 passed_actors__ =
1552 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1553 .into_iter().map(|x| x.0).collect())
1554 ;
1555 }
1556 }
1557 }
1558 Ok(Barrier {
1559 epoch: epoch__,
1560 mutation: mutation__,
1561 tracing_context: tracing_context__.unwrap_or_default(),
1562 kind: kind__.unwrap_or_default(),
1563 passed_actors: passed_actors__.unwrap_or_default(),
1564 })
1565 }
1566 }
1567 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1568 }
1569}
1570impl serde::Serialize for barrier::BarrierKind {
1571 #[allow(deprecated)]
1572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1573 where
1574 S: serde::Serializer,
1575 {
1576 let variant = match self {
1577 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1578 Self::Initial => "BARRIER_KIND_INITIAL",
1579 Self::Barrier => "BARRIER_KIND_BARRIER",
1580 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1581 };
1582 serializer.serialize_str(variant)
1583 }
1584}
1585impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1586 #[allow(deprecated)]
1587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1588 where
1589 D: serde::Deserializer<'de>,
1590 {
1591 const FIELDS: &[&str] = &[
1592 "BARRIER_KIND_UNSPECIFIED",
1593 "BARRIER_KIND_INITIAL",
1594 "BARRIER_KIND_BARRIER",
1595 "BARRIER_KIND_CHECKPOINT",
1596 ];
1597
1598 struct GeneratedVisitor;
1599
1600 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1601 type Value = barrier::BarrierKind;
1602
1603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1604 write!(formatter, "expected one of: {:?}", &FIELDS)
1605 }
1606
1607 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1608 where
1609 E: serde::de::Error,
1610 {
1611 i32::try_from(v)
1612 .ok()
1613 .and_then(|x| x.try_into().ok())
1614 .ok_or_else(|| {
1615 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1616 })
1617 }
1618
1619 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1620 where
1621 E: serde::de::Error,
1622 {
1623 i32::try_from(v)
1624 .ok()
1625 .and_then(|x| x.try_into().ok())
1626 .ok_or_else(|| {
1627 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1628 })
1629 }
1630
1631 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1632 where
1633 E: serde::de::Error,
1634 {
1635 match value {
1636 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1637 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1638 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1639 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1640 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1641 }
1642 }
1643 }
1644 deserializer.deserialize_any(GeneratedVisitor)
1645 }
1646}
1647impl serde::Serialize for BarrierMutation {
1648 #[allow(deprecated)]
1649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1650 where
1651 S: serde::Serializer,
1652 {
1653 use serde::ser::SerializeStruct;
1654 let mut len = 0;
1655 if self.mutation.is_some() {
1656 len += 1;
1657 }
1658 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1659 if let Some(v) = self.mutation.as_ref() {
1660 match v {
1661 barrier_mutation::Mutation::Add(v) => {
1662 struct_ser.serialize_field("add", v)?;
1663 }
1664 barrier_mutation::Mutation::Stop(v) => {
1665 struct_ser.serialize_field("stop", v)?;
1666 }
1667 barrier_mutation::Mutation::Update(v) => {
1668 struct_ser.serialize_field("update", v)?;
1669 }
1670 barrier_mutation::Mutation::Splits(v) => {
1671 struct_ser.serialize_field("splits", v)?;
1672 }
1673 barrier_mutation::Mutation::Pause(v) => {
1674 struct_ser.serialize_field("pause", v)?;
1675 }
1676 barrier_mutation::Mutation::Resume(v) => {
1677 struct_ser.serialize_field("resume", v)?;
1678 }
1679 barrier_mutation::Mutation::Throttle(v) => {
1680 struct_ser.serialize_field("throttle", v)?;
1681 }
1682 barrier_mutation::Mutation::DropSubscriptions(v) => {
1683 struct_ser.serialize_field("dropSubscriptions", v)?;
1684 }
1685 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1686 struct_ser.serialize_field("connectorPropsChange", v)?;
1687 }
1688 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1689 struct_ser.serialize_field("startFragmentBackfill", v)?;
1690 }
1691 barrier_mutation::Mutation::RefreshStart(v) => {
1692 struct_ser.serialize_field("refreshStart", v)?;
1693 }
1694 barrier_mutation::Mutation::LoadFinish(v) => {
1695 struct_ser.serialize_field("loadFinish", v)?;
1696 }
1697 barrier_mutation::Mutation::Combined(v) => {
1698 struct_ser.serialize_field("combined", v)?;
1699 }
1700 }
1701 }
1702 struct_ser.end()
1703 }
1704}
1705impl<'de> serde::Deserialize<'de> for BarrierMutation {
1706 #[allow(deprecated)]
1707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1708 where
1709 D: serde::Deserializer<'de>,
1710 {
1711 const FIELDS: &[&str] = &[
1712 "add",
1713 "stop",
1714 "update",
1715 "splits",
1716 "pause",
1717 "resume",
1718 "throttle",
1719 "drop_subscriptions",
1720 "dropSubscriptions",
1721 "connector_props_change",
1722 "connectorPropsChange",
1723 "start_fragment_backfill",
1724 "startFragmentBackfill",
1725 "refresh_start",
1726 "refreshStart",
1727 "load_finish",
1728 "loadFinish",
1729 "combined",
1730 ];
1731
1732 #[allow(clippy::enum_variant_names)]
1733 enum GeneratedField {
1734 Add,
1735 Stop,
1736 Update,
1737 Splits,
1738 Pause,
1739 Resume,
1740 Throttle,
1741 DropSubscriptions,
1742 ConnectorPropsChange,
1743 StartFragmentBackfill,
1744 RefreshStart,
1745 LoadFinish,
1746 Combined,
1747 }
1748 impl<'de> serde::Deserialize<'de> for GeneratedField {
1749 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1750 where
1751 D: serde::Deserializer<'de>,
1752 {
1753 struct GeneratedVisitor;
1754
1755 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1756 type Value = GeneratedField;
1757
1758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1759 write!(formatter, "expected one of: {:?}", &FIELDS)
1760 }
1761
1762 #[allow(unused_variables)]
1763 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1764 where
1765 E: serde::de::Error,
1766 {
1767 match value {
1768 "add" => Ok(GeneratedField::Add),
1769 "stop" => Ok(GeneratedField::Stop),
1770 "update" => Ok(GeneratedField::Update),
1771 "splits" => Ok(GeneratedField::Splits),
1772 "pause" => Ok(GeneratedField::Pause),
1773 "resume" => Ok(GeneratedField::Resume),
1774 "throttle" => Ok(GeneratedField::Throttle),
1775 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1776 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1777 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1778 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1779 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1780 "combined" => Ok(GeneratedField::Combined),
1781 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1782 }
1783 }
1784 }
1785 deserializer.deserialize_identifier(GeneratedVisitor)
1786 }
1787 }
1788 struct GeneratedVisitor;
1789 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1790 type Value = BarrierMutation;
1791
1792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1793 formatter.write_str("struct stream_plan.BarrierMutation")
1794 }
1795
1796 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1797 where
1798 V: serde::de::MapAccess<'de>,
1799 {
1800 let mut mutation__ = None;
1801 while let Some(k) = map_.next_key()? {
1802 match k {
1803 GeneratedField::Add => {
1804 if mutation__.is_some() {
1805 return Err(serde::de::Error::duplicate_field("add"));
1806 }
1807 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1808;
1809 }
1810 GeneratedField::Stop => {
1811 if mutation__.is_some() {
1812 return Err(serde::de::Error::duplicate_field("stop"));
1813 }
1814 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1815;
1816 }
1817 GeneratedField::Update => {
1818 if mutation__.is_some() {
1819 return Err(serde::de::Error::duplicate_field("update"));
1820 }
1821 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1822;
1823 }
1824 GeneratedField::Splits => {
1825 if mutation__.is_some() {
1826 return Err(serde::de::Error::duplicate_field("splits"));
1827 }
1828 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1829;
1830 }
1831 GeneratedField::Pause => {
1832 if mutation__.is_some() {
1833 return Err(serde::de::Error::duplicate_field("pause"));
1834 }
1835 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1836;
1837 }
1838 GeneratedField::Resume => {
1839 if mutation__.is_some() {
1840 return Err(serde::de::Error::duplicate_field("resume"));
1841 }
1842 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1843;
1844 }
1845 GeneratedField::Throttle => {
1846 if mutation__.is_some() {
1847 return Err(serde::de::Error::duplicate_field("throttle"));
1848 }
1849 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1850;
1851 }
1852 GeneratedField::DropSubscriptions => {
1853 if mutation__.is_some() {
1854 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1855 }
1856 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1857;
1858 }
1859 GeneratedField::ConnectorPropsChange => {
1860 if mutation__.is_some() {
1861 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1862 }
1863 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1864;
1865 }
1866 GeneratedField::StartFragmentBackfill => {
1867 if mutation__.is_some() {
1868 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1869 }
1870 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1871;
1872 }
1873 GeneratedField::RefreshStart => {
1874 if mutation__.is_some() {
1875 return Err(serde::de::Error::duplicate_field("refreshStart"));
1876 }
1877 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
1878;
1879 }
1880 GeneratedField::LoadFinish => {
1881 if mutation__.is_some() {
1882 return Err(serde::de::Error::duplicate_field("loadFinish"));
1883 }
1884 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
1885;
1886 }
1887 GeneratedField::Combined => {
1888 if mutation__.is_some() {
1889 return Err(serde::de::Error::duplicate_field("combined"));
1890 }
1891 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Combined)
1892;
1893 }
1894 }
1895 }
1896 Ok(BarrierMutation {
1897 mutation: mutation__,
1898 })
1899 }
1900 }
1901 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
1902 }
1903}
1904impl serde::Serialize for BarrierRecvNode {
1905 #[allow(deprecated)]
1906 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1907 where
1908 S: serde::Serializer,
1909 {
1910 use serde::ser::SerializeStruct;
1911 let len = 0;
1912 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
1913 struct_ser.end()
1914 }
1915}
1916impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
1917 #[allow(deprecated)]
1918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1919 where
1920 D: serde::Deserializer<'de>,
1921 {
1922 const FIELDS: &[&str] = &[
1923 ];
1924
1925 #[allow(clippy::enum_variant_names)]
1926 enum GeneratedField {
1927 }
1928 impl<'de> serde::Deserialize<'de> for GeneratedField {
1929 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1930 where
1931 D: serde::Deserializer<'de>,
1932 {
1933 struct GeneratedVisitor;
1934
1935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1936 type Value = GeneratedField;
1937
1938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1939 write!(formatter, "expected one of: {:?}", &FIELDS)
1940 }
1941
1942 #[allow(unused_variables)]
1943 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1944 where
1945 E: serde::de::Error,
1946 {
1947 Err(serde::de::Error::unknown_field(value, FIELDS))
1948 }
1949 }
1950 deserializer.deserialize_identifier(GeneratedVisitor)
1951 }
1952 }
1953 struct GeneratedVisitor;
1954 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1955 type Value = BarrierRecvNode;
1956
1957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1958 formatter.write_str("struct stream_plan.BarrierRecvNode")
1959 }
1960
1961 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
1962 where
1963 V: serde::de::MapAccess<'de>,
1964 {
1965 while map_.next_key::<GeneratedField>()?.is_some() {
1966 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1967 }
1968 Ok(BarrierRecvNode {
1969 })
1970 }
1971 }
1972 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
1973 }
1974}
1975impl serde::Serialize for BatchPlanNode {
1976 #[allow(deprecated)]
1977 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1978 where
1979 S: serde::Serializer,
1980 {
1981 use serde::ser::SerializeStruct;
1982 let mut len = 0;
1983 if self.table_desc.is_some() {
1984 len += 1;
1985 }
1986 if !self.column_ids.is_empty() {
1987 len += 1;
1988 }
1989 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
1990 if let Some(v) = self.table_desc.as_ref() {
1991 struct_ser.serialize_field("tableDesc", v)?;
1992 }
1993 if !self.column_ids.is_empty() {
1994 struct_ser.serialize_field("columnIds", &self.column_ids)?;
1995 }
1996 struct_ser.end()
1997 }
1998}
1999impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2000 #[allow(deprecated)]
2001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2002 where
2003 D: serde::Deserializer<'de>,
2004 {
2005 const FIELDS: &[&str] = &[
2006 "table_desc",
2007 "tableDesc",
2008 "column_ids",
2009 "columnIds",
2010 ];
2011
2012 #[allow(clippy::enum_variant_names)]
2013 enum GeneratedField {
2014 TableDesc,
2015 ColumnIds,
2016 }
2017 impl<'de> serde::Deserialize<'de> for GeneratedField {
2018 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2019 where
2020 D: serde::Deserializer<'de>,
2021 {
2022 struct GeneratedVisitor;
2023
2024 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2025 type Value = GeneratedField;
2026
2027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2028 write!(formatter, "expected one of: {:?}", &FIELDS)
2029 }
2030
2031 #[allow(unused_variables)]
2032 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2033 where
2034 E: serde::de::Error,
2035 {
2036 match value {
2037 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2038 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2039 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2040 }
2041 }
2042 }
2043 deserializer.deserialize_identifier(GeneratedVisitor)
2044 }
2045 }
2046 struct GeneratedVisitor;
2047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2048 type Value = BatchPlanNode;
2049
2050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2051 formatter.write_str("struct stream_plan.BatchPlanNode")
2052 }
2053
2054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2055 where
2056 V: serde::de::MapAccess<'de>,
2057 {
2058 let mut table_desc__ = None;
2059 let mut column_ids__ = None;
2060 while let Some(k) = map_.next_key()? {
2061 match k {
2062 GeneratedField::TableDesc => {
2063 if table_desc__.is_some() {
2064 return Err(serde::de::Error::duplicate_field("tableDesc"));
2065 }
2066 table_desc__ = map_.next_value()?;
2067 }
2068 GeneratedField::ColumnIds => {
2069 if column_ids__.is_some() {
2070 return Err(serde::de::Error::duplicate_field("columnIds"));
2071 }
2072 column_ids__ =
2073 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2074 .into_iter().map(|x| x.0).collect())
2075 ;
2076 }
2077 }
2078 }
2079 Ok(BatchPlanNode {
2080 table_desc: table_desc__,
2081 column_ids: column_ids__.unwrap_or_default(),
2082 })
2083 }
2084 }
2085 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2086 }
2087}
2088impl serde::Serialize for CdcFilterNode {
2089 #[allow(deprecated)]
2090 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2091 where
2092 S: serde::Serializer,
2093 {
2094 use serde::ser::SerializeStruct;
2095 let mut len = 0;
2096 if self.search_condition.is_some() {
2097 len += 1;
2098 }
2099 if self.upstream_source_id != 0 {
2100 len += 1;
2101 }
2102 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2103 if let Some(v) = self.search_condition.as_ref() {
2104 struct_ser.serialize_field("searchCondition", v)?;
2105 }
2106 if self.upstream_source_id != 0 {
2107 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2108 }
2109 struct_ser.end()
2110 }
2111}
2112impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2113 #[allow(deprecated)]
2114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2115 where
2116 D: serde::Deserializer<'de>,
2117 {
2118 const FIELDS: &[&str] = &[
2119 "search_condition",
2120 "searchCondition",
2121 "upstream_source_id",
2122 "upstreamSourceId",
2123 ];
2124
2125 #[allow(clippy::enum_variant_names)]
2126 enum GeneratedField {
2127 SearchCondition,
2128 UpstreamSourceId,
2129 }
2130 impl<'de> serde::Deserialize<'de> for GeneratedField {
2131 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2132 where
2133 D: serde::Deserializer<'de>,
2134 {
2135 struct GeneratedVisitor;
2136
2137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2138 type Value = GeneratedField;
2139
2140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2141 write!(formatter, "expected one of: {:?}", &FIELDS)
2142 }
2143
2144 #[allow(unused_variables)]
2145 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2146 where
2147 E: serde::de::Error,
2148 {
2149 match value {
2150 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2151 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2152 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2153 }
2154 }
2155 }
2156 deserializer.deserialize_identifier(GeneratedVisitor)
2157 }
2158 }
2159 struct GeneratedVisitor;
2160 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2161 type Value = CdcFilterNode;
2162
2163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2164 formatter.write_str("struct stream_plan.CdcFilterNode")
2165 }
2166
2167 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2168 where
2169 V: serde::de::MapAccess<'de>,
2170 {
2171 let mut search_condition__ = None;
2172 let mut upstream_source_id__ = None;
2173 while let Some(k) = map_.next_key()? {
2174 match k {
2175 GeneratedField::SearchCondition => {
2176 if search_condition__.is_some() {
2177 return Err(serde::de::Error::duplicate_field("searchCondition"));
2178 }
2179 search_condition__ = map_.next_value()?;
2180 }
2181 GeneratedField::UpstreamSourceId => {
2182 if upstream_source_id__.is_some() {
2183 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2184 }
2185 upstream_source_id__ =
2186 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2187 ;
2188 }
2189 }
2190 }
2191 Ok(CdcFilterNode {
2192 search_condition: search_condition__,
2193 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2194 })
2195 }
2196 }
2197 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2198 }
2199}
2200impl serde::Serialize for ChangeLogNode {
2201 #[allow(deprecated)]
2202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2203 where
2204 S: serde::Serializer,
2205 {
2206 use serde::ser::SerializeStruct;
2207 let mut len = 0;
2208 if self.need_op {
2209 len += 1;
2210 }
2211 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2212 if self.need_op {
2213 struct_ser.serialize_field("needOp", &self.need_op)?;
2214 }
2215 struct_ser.end()
2216 }
2217}
2218impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2219 #[allow(deprecated)]
2220 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2221 where
2222 D: serde::Deserializer<'de>,
2223 {
2224 const FIELDS: &[&str] = &[
2225 "need_op",
2226 "needOp",
2227 ];
2228
2229 #[allow(clippy::enum_variant_names)]
2230 enum GeneratedField {
2231 NeedOp,
2232 }
2233 impl<'de> serde::Deserialize<'de> for GeneratedField {
2234 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2235 where
2236 D: serde::Deserializer<'de>,
2237 {
2238 struct GeneratedVisitor;
2239
2240 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2241 type Value = GeneratedField;
2242
2243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2244 write!(formatter, "expected one of: {:?}", &FIELDS)
2245 }
2246
2247 #[allow(unused_variables)]
2248 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2249 where
2250 E: serde::de::Error,
2251 {
2252 match value {
2253 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2254 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2255 }
2256 }
2257 }
2258 deserializer.deserialize_identifier(GeneratedVisitor)
2259 }
2260 }
2261 struct GeneratedVisitor;
2262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2263 type Value = ChangeLogNode;
2264
2265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2266 formatter.write_str("struct stream_plan.ChangeLogNode")
2267 }
2268
2269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2270 where
2271 V: serde::de::MapAccess<'de>,
2272 {
2273 let mut need_op__ = None;
2274 while let Some(k) = map_.next_key()? {
2275 match k {
2276 GeneratedField::NeedOp => {
2277 if need_op__.is_some() {
2278 return Err(serde::de::Error::duplicate_field("needOp"));
2279 }
2280 need_op__ = Some(map_.next_value()?);
2281 }
2282 }
2283 }
2284 Ok(ChangeLogNode {
2285 need_op: need_op__.unwrap_or_default(),
2286 })
2287 }
2288 }
2289 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2290 }
2291}
2292impl serde::Serialize for CombinedMutation {
2293 #[allow(deprecated)]
2294 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2295 where
2296 S: serde::Serializer,
2297 {
2298 use serde::ser::SerializeStruct;
2299 let mut len = 0;
2300 if !self.mutations.is_empty() {
2301 len += 1;
2302 }
2303 let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2304 if !self.mutations.is_empty() {
2305 struct_ser.serialize_field("mutations", &self.mutations)?;
2306 }
2307 struct_ser.end()
2308 }
2309}
2310impl<'de> serde::Deserialize<'de> for CombinedMutation {
2311 #[allow(deprecated)]
2312 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2313 where
2314 D: serde::Deserializer<'de>,
2315 {
2316 const FIELDS: &[&str] = &[
2317 "mutations",
2318 ];
2319
2320 #[allow(clippy::enum_variant_names)]
2321 enum GeneratedField {
2322 Mutations,
2323 }
2324 impl<'de> serde::Deserialize<'de> for GeneratedField {
2325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2326 where
2327 D: serde::Deserializer<'de>,
2328 {
2329 struct GeneratedVisitor;
2330
2331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2332 type Value = GeneratedField;
2333
2334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2335 write!(formatter, "expected one of: {:?}", &FIELDS)
2336 }
2337
2338 #[allow(unused_variables)]
2339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2340 where
2341 E: serde::de::Error,
2342 {
2343 match value {
2344 "mutations" => Ok(GeneratedField::Mutations),
2345 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2346 }
2347 }
2348 }
2349 deserializer.deserialize_identifier(GeneratedVisitor)
2350 }
2351 }
2352 struct GeneratedVisitor;
2353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2354 type Value = CombinedMutation;
2355
2356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2357 formatter.write_str("struct stream_plan.CombinedMutation")
2358 }
2359
2360 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2361 where
2362 V: serde::de::MapAccess<'de>,
2363 {
2364 let mut mutations__ = None;
2365 while let Some(k) = map_.next_key()? {
2366 match k {
2367 GeneratedField::Mutations => {
2368 if mutations__.is_some() {
2369 return Err(serde::de::Error::duplicate_field("mutations"));
2370 }
2371 mutations__ = Some(map_.next_value()?);
2372 }
2373 }
2374 }
2375 Ok(CombinedMutation {
2376 mutations: mutations__.unwrap_or_default(),
2377 })
2378 }
2379 }
2380 deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2381 }
2382}
2383impl serde::Serialize for ConnectorPropsChangeMutation {
2384 #[allow(deprecated)]
2385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2386 where
2387 S: serde::Serializer,
2388 {
2389 use serde::ser::SerializeStruct;
2390 let mut len = 0;
2391 if !self.connector_props_infos.is_empty() {
2392 len += 1;
2393 }
2394 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2395 if !self.connector_props_infos.is_empty() {
2396 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2397 }
2398 struct_ser.end()
2399 }
2400}
2401impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2402 #[allow(deprecated)]
2403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2404 where
2405 D: serde::Deserializer<'de>,
2406 {
2407 const FIELDS: &[&str] = &[
2408 "connector_props_infos",
2409 "connectorPropsInfos",
2410 ];
2411
2412 #[allow(clippy::enum_variant_names)]
2413 enum GeneratedField {
2414 ConnectorPropsInfos,
2415 }
2416 impl<'de> serde::Deserialize<'de> for GeneratedField {
2417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2418 where
2419 D: serde::Deserializer<'de>,
2420 {
2421 struct GeneratedVisitor;
2422
2423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2424 type Value = GeneratedField;
2425
2426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2427 write!(formatter, "expected one of: {:?}", &FIELDS)
2428 }
2429
2430 #[allow(unused_variables)]
2431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2432 where
2433 E: serde::de::Error,
2434 {
2435 match value {
2436 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2437 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2438 }
2439 }
2440 }
2441 deserializer.deserialize_identifier(GeneratedVisitor)
2442 }
2443 }
2444 struct GeneratedVisitor;
2445 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2446 type Value = ConnectorPropsChangeMutation;
2447
2448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2449 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2450 }
2451
2452 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2453 where
2454 V: serde::de::MapAccess<'de>,
2455 {
2456 let mut connector_props_infos__ = None;
2457 while let Some(k) = map_.next_key()? {
2458 match k {
2459 GeneratedField::ConnectorPropsInfos => {
2460 if connector_props_infos__.is_some() {
2461 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2462 }
2463 connector_props_infos__ = Some(
2464 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2465 .into_iter().map(|(k,v)| (k.0, v)).collect()
2466 );
2467 }
2468 }
2469 }
2470 Ok(ConnectorPropsChangeMutation {
2471 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2472 })
2473 }
2474 }
2475 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2476 }
2477}
2478impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2479 #[allow(deprecated)]
2480 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2481 where
2482 S: serde::Serializer,
2483 {
2484 use serde::ser::SerializeStruct;
2485 let mut len = 0;
2486 if !self.connector_props_info.is_empty() {
2487 len += 1;
2488 }
2489 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2490 if !self.connector_props_info.is_empty() {
2491 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2492 }
2493 struct_ser.end()
2494 }
2495}
2496impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2497 #[allow(deprecated)]
2498 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2499 where
2500 D: serde::Deserializer<'de>,
2501 {
2502 const FIELDS: &[&str] = &[
2503 "connector_props_info",
2504 "connectorPropsInfo",
2505 ];
2506
2507 #[allow(clippy::enum_variant_names)]
2508 enum GeneratedField {
2509 ConnectorPropsInfo,
2510 }
2511 impl<'de> serde::Deserialize<'de> for GeneratedField {
2512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2513 where
2514 D: serde::Deserializer<'de>,
2515 {
2516 struct GeneratedVisitor;
2517
2518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2519 type Value = GeneratedField;
2520
2521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2522 write!(formatter, "expected one of: {:?}", &FIELDS)
2523 }
2524
2525 #[allow(unused_variables)]
2526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2527 where
2528 E: serde::de::Error,
2529 {
2530 match value {
2531 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2533 }
2534 }
2535 }
2536 deserializer.deserialize_identifier(GeneratedVisitor)
2537 }
2538 }
2539 struct GeneratedVisitor;
2540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2541 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2542
2543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2544 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2545 }
2546
2547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2548 where
2549 V: serde::de::MapAccess<'de>,
2550 {
2551 let mut connector_props_info__ = None;
2552 while let Some(k) = map_.next_key()? {
2553 match k {
2554 GeneratedField::ConnectorPropsInfo => {
2555 if connector_props_info__.is_some() {
2556 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2557 }
2558 connector_props_info__ = Some(
2559 map_.next_value::<std::collections::HashMap<_, _>>()?
2560 );
2561 }
2562 }
2563 }
2564 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2565 connector_props_info: connector_props_info__.unwrap_or_default(),
2566 })
2567 }
2568 }
2569 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2570 }
2571}
2572impl serde::Serialize for DedupNode {
2573 #[allow(deprecated)]
2574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2575 where
2576 S: serde::Serializer,
2577 {
2578 use serde::ser::SerializeStruct;
2579 let mut len = 0;
2580 if self.state_table.is_some() {
2581 len += 1;
2582 }
2583 if !self.dedup_column_indices.is_empty() {
2584 len += 1;
2585 }
2586 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2587 if let Some(v) = self.state_table.as_ref() {
2588 struct_ser.serialize_field("stateTable", v)?;
2589 }
2590 if !self.dedup_column_indices.is_empty() {
2591 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2592 }
2593 struct_ser.end()
2594 }
2595}
2596impl<'de> serde::Deserialize<'de> for DedupNode {
2597 #[allow(deprecated)]
2598 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2599 where
2600 D: serde::Deserializer<'de>,
2601 {
2602 const FIELDS: &[&str] = &[
2603 "state_table",
2604 "stateTable",
2605 "dedup_column_indices",
2606 "dedupColumnIndices",
2607 ];
2608
2609 #[allow(clippy::enum_variant_names)]
2610 enum GeneratedField {
2611 StateTable,
2612 DedupColumnIndices,
2613 }
2614 impl<'de> serde::Deserialize<'de> for GeneratedField {
2615 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2616 where
2617 D: serde::Deserializer<'de>,
2618 {
2619 struct GeneratedVisitor;
2620
2621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2622 type Value = GeneratedField;
2623
2624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2625 write!(formatter, "expected one of: {:?}", &FIELDS)
2626 }
2627
2628 #[allow(unused_variables)]
2629 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2630 where
2631 E: serde::de::Error,
2632 {
2633 match value {
2634 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2635 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2636 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2637 }
2638 }
2639 }
2640 deserializer.deserialize_identifier(GeneratedVisitor)
2641 }
2642 }
2643 struct GeneratedVisitor;
2644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2645 type Value = DedupNode;
2646
2647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2648 formatter.write_str("struct stream_plan.DedupNode")
2649 }
2650
2651 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2652 where
2653 V: serde::de::MapAccess<'de>,
2654 {
2655 let mut state_table__ = None;
2656 let mut dedup_column_indices__ = None;
2657 while let Some(k) = map_.next_key()? {
2658 match k {
2659 GeneratedField::StateTable => {
2660 if state_table__.is_some() {
2661 return Err(serde::de::Error::duplicate_field("stateTable"));
2662 }
2663 state_table__ = map_.next_value()?;
2664 }
2665 GeneratedField::DedupColumnIndices => {
2666 if dedup_column_indices__.is_some() {
2667 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2668 }
2669 dedup_column_indices__ =
2670 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2671 .into_iter().map(|x| x.0).collect())
2672 ;
2673 }
2674 }
2675 }
2676 Ok(DedupNode {
2677 state_table: state_table__,
2678 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2679 })
2680 }
2681 }
2682 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2683 }
2684}
2685impl serde::Serialize for DeltaExpression {
2686 #[allow(deprecated)]
2687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2688 where
2689 S: serde::Serializer,
2690 {
2691 use serde::ser::SerializeStruct;
2692 let mut len = 0;
2693 if self.delta_type != 0 {
2694 len += 1;
2695 }
2696 if self.delta.is_some() {
2697 len += 1;
2698 }
2699 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2700 if self.delta_type != 0 {
2701 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2702 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2703 struct_ser.serialize_field("deltaType", &v)?;
2704 }
2705 if let Some(v) = self.delta.as_ref() {
2706 struct_ser.serialize_field("delta", v)?;
2707 }
2708 struct_ser.end()
2709 }
2710}
2711impl<'de> serde::Deserialize<'de> for DeltaExpression {
2712 #[allow(deprecated)]
2713 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2714 where
2715 D: serde::Deserializer<'de>,
2716 {
2717 const FIELDS: &[&str] = &[
2718 "delta_type",
2719 "deltaType",
2720 "delta",
2721 ];
2722
2723 #[allow(clippy::enum_variant_names)]
2724 enum GeneratedField {
2725 DeltaType,
2726 Delta,
2727 }
2728 impl<'de> serde::Deserialize<'de> for GeneratedField {
2729 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2730 where
2731 D: serde::Deserializer<'de>,
2732 {
2733 struct GeneratedVisitor;
2734
2735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2736 type Value = GeneratedField;
2737
2738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2739 write!(formatter, "expected one of: {:?}", &FIELDS)
2740 }
2741
2742 #[allow(unused_variables)]
2743 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2744 where
2745 E: serde::de::Error,
2746 {
2747 match value {
2748 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2749 "delta" => Ok(GeneratedField::Delta),
2750 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2751 }
2752 }
2753 }
2754 deserializer.deserialize_identifier(GeneratedVisitor)
2755 }
2756 }
2757 struct GeneratedVisitor;
2758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2759 type Value = DeltaExpression;
2760
2761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2762 formatter.write_str("struct stream_plan.DeltaExpression")
2763 }
2764
2765 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2766 where
2767 V: serde::de::MapAccess<'de>,
2768 {
2769 let mut delta_type__ = None;
2770 let mut delta__ = None;
2771 while let Some(k) = map_.next_key()? {
2772 match k {
2773 GeneratedField::DeltaType => {
2774 if delta_type__.is_some() {
2775 return Err(serde::de::Error::duplicate_field("deltaType"));
2776 }
2777 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2778 }
2779 GeneratedField::Delta => {
2780 if delta__.is_some() {
2781 return Err(serde::de::Error::duplicate_field("delta"));
2782 }
2783 delta__ = map_.next_value()?;
2784 }
2785 }
2786 }
2787 Ok(DeltaExpression {
2788 delta_type: delta_type__.unwrap_or_default(),
2789 delta: delta__,
2790 })
2791 }
2792 }
2793 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2794 }
2795}
2796impl serde::Serialize for DeltaIndexJoinNode {
2797 #[allow(deprecated)]
2798 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2799 where
2800 S: serde::Serializer,
2801 {
2802 use serde::ser::SerializeStruct;
2803 let mut len = 0;
2804 if self.join_type != 0 {
2805 len += 1;
2806 }
2807 if !self.left_key.is_empty() {
2808 len += 1;
2809 }
2810 if !self.right_key.is_empty() {
2811 len += 1;
2812 }
2813 if self.condition.is_some() {
2814 len += 1;
2815 }
2816 if self.left_table_id != 0 {
2817 len += 1;
2818 }
2819 if self.right_table_id != 0 {
2820 len += 1;
2821 }
2822 if self.left_info.is_some() {
2823 len += 1;
2824 }
2825 if self.right_info.is_some() {
2826 len += 1;
2827 }
2828 if !self.output_indices.is_empty() {
2829 len += 1;
2830 }
2831 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2832 if self.join_type != 0 {
2833 let v = super::plan_common::JoinType::try_from(self.join_type)
2834 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2835 struct_ser.serialize_field("joinType", &v)?;
2836 }
2837 if !self.left_key.is_empty() {
2838 struct_ser.serialize_field("leftKey", &self.left_key)?;
2839 }
2840 if !self.right_key.is_empty() {
2841 struct_ser.serialize_field("rightKey", &self.right_key)?;
2842 }
2843 if let Some(v) = self.condition.as_ref() {
2844 struct_ser.serialize_field("condition", v)?;
2845 }
2846 if self.left_table_id != 0 {
2847 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2848 }
2849 if self.right_table_id != 0 {
2850 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2851 }
2852 if let Some(v) = self.left_info.as_ref() {
2853 struct_ser.serialize_field("leftInfo", v)?;
2854 }
2855 if let Some(v) = self.right_info.as_ref() {
2856 struct_ser.serialize_field("rightInfo", v)?;
2857 }
2858 if !self.output_indices.is_empty() {
2859 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2860 }
2861 struct_ser.end()
2862 }
2863}
2864impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
2865 #[allow(deprecated)]
2866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2867 where
2868 D: serde::Deserializer<'de>,
2869 {
2870 const FIELDS: &[&str] = &[
2871 "join_type",
2872 "joinType",
2873 "left_key",
2874 "leftKey",
2875 "right_key",
2876 "rightKey",
2877 "condition",
2878 "left_table_id",
2879 "leftTableId",
2880 "right_table_id",
2881 "rightTableId",
2882 "left_info",
2883 "leftInfo",
2884 "right_info",
2885 "rightInfo",
2886 "output_indices",
2887 "outputIndices",
2888 ];
2889
2890 #[allow(clippy::enum_variant_names)]
2891 enum GeneratedField {
2892 JoinType,
2893 LeftKey,
2894 RightKey,
2895 Condition,
2896 LeftTableId,
2897 RightTableId,
2898 LeftInfo,
2899 RightInfo,
2900 OutputIndices,
2901 }
2902 impl<'de> serde::Deserialize<'de> for GeneratedField {
2903 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2904 where
2905 D: serde::Deserializer<'de>,
2906 {
2907 struct GeneratedVisitor;
2908
2909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2910 type Value = GeneratedField;
2911
2912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2913 write!(formatter, "expected one of: {:?}", &FIELDS)
2914 }
2915
2916 #[allow(unused_variables)]
2917 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2918 where
2919 E: serde::de::Error,
2920 {
2921 match value {
2922 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
2923 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
2924 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
2925 "condition" => Ok(GeneratedField::Condition),
2926 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
2927 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
2928 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
2929 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
2930 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2932 }
2933 }
2934 }
2935 deserializer.deserialize_identifier(GeneratedVisitor)
2936 }
2937 }
2938 struct GeneratedVisitor;
2939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2940 type Value = DeltaIndexJoinNode;
2941
2942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2943 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
2944 }
2945
2946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
2947 where
2948 V: serde::de::MapAccess<'de>,
2949 {
2950 let mut join_type__ = None;
2951 let mut left_key__ = None;
2952 let mut right_key__ = None;
2953 let mut condition__ = None;
2954 let mut left_table_id__ = None;
2955 let mut right_table_id__ = None;
2956 let mut left_info__ = None;
2957 let mut right_info__ = None;
2958 let mut output_indices__ = None;
2959 while let Some(k) = map_.next_key()? {
2960 match k {
2961 GeneratedField::JoinType => {
2962 if join_type__.is_some() {
2963 return Err(serde::de::Error::duplicate_field("joinType"));
2964 }
2965 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
2966 }
2967 GeneratedField::LeftKey => {
2968 if left_key__.is_some() {
2969 return Err(serde::de::Error::duplicate_field("leftKey"));
2970 }
2971 left_key__ =
2972 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2973 .into_iter().map(|x| x.0).collect())
2974 ;
2975 }
2976 GeneratedField::RightKey => {
2977 if right_key__.is_some() {
2978 return Err(serde::de::Error::duplicate_field("rightKey"));
2979 }
2980 right_key__ =
2981 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2982 .into_iter().map(|x| x.0).collect())
2983 ;
2984 }
2985 GeneratedField::Condition => {
2986 if condition__.is_some() {
2987 return Err(serde::de::Error::duplicate_field("condition"));
2988 }
2989 condition__ = map_.next_value()?;
2990 }
2991 GeneratedField::LeftTableId => {
2992 if left_table_id__.is_some() {
2993 return Err(serde::de::Error::duplicate_field("leftTableId"));
2994 }
2995 left_table_id__ =
2996 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2997 ;
2998 }
2999 GeneratedField::RightTableId => {
3000 if right_table_id__.is_some() {
3001 return Err(serde::de::Error::duplicate_field("rightTableId"));
3002 }
3003 right_table_id__ =
3004 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3005 ;
3006 }
3007 GeneratedField::LeftInfo => {
3008 if left_info__.is_some() {
3009 return Err(serde::de::Error::duplicate_field("leftInfo"));
3010 }
3011 left_info__ = map_.next_value()?;
3012 }
3013 GeneratedField::RightInfo => {
3014 if right_info__.is_some() {
3015 return Err(serde::de::Error::duplicate_field("rightInfo"));
3016 }
3017 right_info__ = map_.next_value()?;
3018 }
3019 GeneratedField::OutputIndices => {
3020 if output_indices__.is_some() {
3021 return Err(serde::de::Error::duplicate_field("outputIndices"));
3022 }
3023 output_indices__ =
3024 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3025 .into_iter().map(|x| x.0).collect())
3026 ;
3027 }
3028 }
3029 }
3030 Ok(DeltaIndexJoinNode {
3031 join_type: join_type__.unwrap_or_default(),
3032 left_key: left_key__.unwrap_or_default(),
3033 right_key: right_key__.unwrap_or_default(),
3034 condition: condition__,
3035 left_table_id: left_table_id__.unwrap_or_default(),
3036 right_table_id: right_table_id__.unwrap_or_default(),
3037 left_info: left_info__,
3038 right_info: right_info__,
3039 output_indices: output_indices__.unwrap_or_default(),
3040 })
3041 }
3042 }
3043 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3044 }
3045}
3046impl serde::Serialize for DispatchOutputMapping {
3047 #[allow(deprecated)]
3048 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3049 where
3050 S: serde::Serializer,
3051 {
3052 use serde::ser::SerializeStruct;
3053 let mut len = 0;
3054 if !self.indices.is_empty() {
3055 len += 1;
3056 }
3057 if !self.types.is_empty() {
3058 len += 1;
3059 }
3060 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3061 if !self.indices.is_empty() {
3062 struct_ser.serialize_field("indices", &self.indices)?;
3063 }
3064 if !self.types.is_empty() {
3065 struct_ser.serialize_field("types", &self.types)?;
3066 }
3067 struct_ser.end()
3068 }
3069}
3070impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3071 #[allow(deprecated)]
3072 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3073 where
3074 D: serde::Deserializer<'de>,
3075 {
3076 const FIELDS: &[&str] = &[
3077 "indices",
3078 "types",
3079 ];
3080
3081 #[allow(clippy::enum_variant_names)]
3082 enum GeneratedField {
3083 Indices,
3084 Types,
3085 }
3086 impl<'de> serde::Deserialize<'de> for GeneratedField {
3087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3088 where
3089 D: serde::Deserializer<'de>,
3090 {
3091 struct GeneratedVisitor;
3092
3093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3094 type Value = GeneratedField;
3095
3096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3097 write!(formatter, "expected one of: {:?}", &FIELDS)
3098 }
3099
3100 #[allow(unused_variables)]
3101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3102 where
3103 E: serde::de::Error,
3104 {
3105 match value {
3106 "indices" => Ok(GeneratedField::Indices),
3107 "types" => Ok(GeneratedField::Types),
3108 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3109 }
3110 }
3111 }
3112 deserializer.deserialize_identifier(GeneratedVisitor)
3113 }
3114 }
3115 struct GeneratedVisitor;
3116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3117 type Value = DispatchOutputMapping;
3118
3119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3120 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3121 }
3122
3123 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3124 where
3125 V: serde::de::MapAccess<'de>,
3126 {
3127 let mut indices__ = None;
3128 let mut types__ = None;
3129 while let Some(k) = map_.next_key()? {
3130 match k {
3131 GeneratedField::Indices => {
3132 if indices__.is_some() {
3133 return Err(serde::de::Error::duplicate_field("indices"));
3134 }
3135 indices__ =
3136 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3137 .into_iter().map(|x| x.0).collect())
3138 ;
3139 }
3140 GeneratedField::Types => {
3141 if types__.is_some() {
3142 return Err(serde::de::Error::duplicate_field("types"));
3143 }
3144 types__ = Some(map_.next_value()?);
3145 }
3146 }
3147 }
3148 Ok(DispatchOutputMapping {
3149 indices: indices__.unwrap_or_default(),
3150 types: types__.unwrap_or_default(),
3151 })
3152 }
3153 }
3154 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3155 }
3156}
3157impl serde::Serialize for dispatch_output_mapping::TypePair {
3158 #[allow(deprecated)]
3159 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3160 where
3161 S: serde::Serializer,
3162 {
3163 use serde::ser::SerializeStruct;
3164 let mut len = 0;
3165 if self.upstream.is_some() {
3166 len += 1;
3167 }
3168 if self.downstream.is_some() {
3169 len += 1;
3170 }
3171 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3172 if let Some(v) = self.upstream.as_ref() {
3173 struct_ser.serialize_field("upstream", v)?;
3174 }
3175 if let Some(v) = self.downstream.as_ref() {
3176 struct_ser.serialize_field("downstream", v)?;
3177 }
3178 struct_ser.end()
3179 }
3180}
3181impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3182 #[allow(deprecated)]
3183 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3184 where
3185 D: serde::Deserializer<'de>,
3186 {
3187 const FIELDS: &[&str] = &[
3188 "upstream",
3189 "downstream",
3190 ];
3191
3192 #[allow(clippy::enum_variant_names)]
3193 enum GeneratedField {
3194 Upstream,
3195 Downstream,
3196 }
3197 impl<'de> serde::Deserialize<'de> for GeneratedField {
3198 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3199 where
3200 D: serde::Deserializer<'de>,
3201 {
3202 struct GeneratedVisitor;
3203
3204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3205 type Value = GeneratedField;
3206
3207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3208 write!(formatter, "expected one of: {:?}", &FIELDS)
3209 }
3210
3211 #[allow(unused_variables)]
3212 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3213 where
3214 E: serde::de::Error,
3215 {
3216 match value {
3217 "upstream" => Ok(GeneratedField::Upstream),
3218 "downstream" => Ok(GeneratedField::Downstream),
3219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3220 }
3221 }
3222 }
3223 deserializer.deserialize_identifier(GeneratedVisitor)
3224 }
3225 }
3226 struct GeneratedVisitor;
3227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3228 type Value = dispatch_output_mapping::TypePair;
3229
3230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3231 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3232 }
3233
3234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3235 where
3236 V: serde::de::MapAccess<'de>,
3237 {
3238 let mut upstream__ = None;
3239 let mut downstream__ = None;
3240 while let Some(k) = map_.next_key()? {
3241 match k {
3242 GeneratedField::Upstream => {
3243 if upstream__.is_some() {
3244 return Err(serde::de::Error::duplicate_field("upstream"));
3245 }
3246 upstream__ = map_.next_value()?;
3247 }
3248 GeneratedField::Downstream => {
3249 if downstream__.is_some() {
3250 return Err(serde::de::Error::duplicate_field("downstream"));
3251 }
3252 downstream__ = map_.next_value()?;
3253 }
3254 }
3255 }
3256 Ok(dispatch_output_mapping::TypePair {
3257 upstream: upstream__,
3258 downstream: downstream__,
3259 })
3260 }
3261 }
3262 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3263 }
3264}
3265impl serde::Serialize for DispatchStrategy {
3266 #[allow(deprecated)]
3267 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3268 where
3269 S: serde::Serializer,
3270 {
3271 use serde::ser::SerializeStruct;
3272 let mut len = 0;
3273 if self.r#type != 0 {
3274 len += 1;
3275 }
3276 if !self.dist_key_indices.is_empty() {
3277 len += 1;
3278 }
3279 if self.output_mapping.is_some() {
3280 len += 1;
3281 }
3282 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3283 if self.r#type != 0 {
3284 let v = DispatcherType::try_from(self.r#type)
3285 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3286 struct_ser.serialize_field("type", &v)?;
3287 }
3288 if !self.dist_key_indices.is_empty() {
3289 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3290 }
3291 if let Some(v) = self.output_mapping.as_ref() {
3292 struct_ser.serialize_field("outputMapping", v)?;
3293 }
3294 struct_ser.end()
3295 }
3296}
3297impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3298 #[allow(deprecated)]
3299 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3300 where
3301 D: serde::Deserializer<'de>,
3302 {
3303 const FIELDS: &[&str] = &[
3304 "type",
3305 "dist_key_indices",
3306 "distKeyIndices",
3307 "output_mapping",
3308 "outputMapping",
3309 ];
3310
3311 #[allow(clippy::enum_variant_names)]
3312 enum GeneratedField {
3313 Type,
3314 DistKeyIndices,
3315 OutputMapping,
3316 }
3317 impl<'de> serde::Deserialize<'de> for GeneratedField {
3318 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3319 where
3320 D: serde::Deserializer<'de>,
3321 {
3322 struct GeneratedVisitor;
3323
3324 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3325 type Value = GeneratedField;
3326
3327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3328 write!(formatter, "expected one of: {:?}", &FIELDS)
3329 }
3330
3331 #[allow(unused_variables)]
3332 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3333 where
3334 E: serde::de::Error,
3335 {
3336 match value {
3337 "type" => Ok(GeneratedField::Type),
3338 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3339 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3340 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3341 }
3342 }
3343 }
3344 deserializer.deserialize_identifier(GeneratedVisitor)
3345 }
3346 }
3347 struct GeneratedVisitor;
3348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3349 type Value = DispatchStrategy;
3350
3351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3352 formatter.write_str("struct stream_plan.DispatchStrategy")
3353 }
3354
3355 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3356 where
3357 V: serde::de::MapAccess<'de>,
3358 {
3359 let mut r#type__ = None;
3360 let mut dist_key_indices__ = None;
3361 let mut output_mapping__ = None;
3362 while let Some(k) = map_.next_key()? {
3363 match k {
3364 GeneratedField::Type => {
3365 if r#type__.is_some() {
3366 return Err(serde::de::Error::duplicate_field("type"));
3367 }
3368 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3369 }
3370 GeneratedField::DistKeyIndices => {
3371 if dist_key_indices__.is_some() {
3372 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3373 }
3374 dist_key_indices__ =
3375 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3376 .into_iter().map(|x| x.0).collect())
3377 ;
3378 }
3379 GeneratedField::OutputMapping => {
3380 if output_mapping__.is_some() {
3381 return Err(serde::de::Error::duplicate_field("outputMapping"));
3382 }
3383 output_mapping__ = map_.next_value()?;
3384 }
3385 }
3386 }
3387 Ok(DispatchStrategy {
3388 r#type: r#type__.unwrap_or_default(),
3389 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3390 output_mapping: output_mapping__,
3391 })
3392 }
3393 }
3394 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3395 }
3396}
3397impl serde::Serialize for Dispatcher {
3398 #[allow(deprecated)]
3399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3400 where
3401 S: serde::Serializer,
3402 {
3403 use serde::ser::SerializeStruct;
3404 let mut len = 0;
3405 if self.r#type != 0 {
3406 len += 1;
3407 }
3408 if !self.dist_key_indices.is_empty() {
3409 len += 1;
3410 }
3411 if self.output_mapping.is_some() {
3412 len += 1;
3413 }
3414 if self.hash_mapping.is_some() {
3415 len += 1;
3416 }
3417 if self.dispatcher_id != 0 {
3418 len += 1;
3419 }
3420 if !self.downstream_actor_id.is_empty() {
3421 len += 1;
3422 }
3423 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3424 if self.r#type != 0 {
3425 let v = DispatcherType::try_from(self.r#type)
3426 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3427 struct_ser.serialize_field("type", &v)?;
3428 }
3429 if !self.dist_key_indices.is_empty() {
3430 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3431 }
3432 if let Some(v) = self.output_mapping.as_ref() {
3433 struct_ser.serialize_field("outputMapping", v)?;
3434 }
3435 if let Some(v) = self.hash_mapping.as_ref() {
3436 struct_ser.serialize_field("hashMapping", v)?;
3437 }
3438 if self.dispatcher_id != 0 {
3439 #[allow(clippy::needless_borrow)]
3440 #[allow(clippy::needless_borrows_for_generic_args)]
3441 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3442 }
3443 if !self.downstream_actor_id.is_empty() {
3444 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3445 }
3446 struct_ser.end()
3447 }
3448}
3449impl<'de> serde::Deserialize<'de> for Dispatcher {
3450 #[allow(deprecated)]
3451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3452 where
3453 D: serde::Deserializer<'de>,
3454 {
3455 const FIELDS: &[&str] = &[
3456 "type",
3457 "dist_key_indices",
3458 "distKeyIndices",
3459 "output_mapping",
3460 "outputMapping",
3461 "hash_mapping",
3462 "hashMapping",
3463 "dispatcher_id",
3464 "dispatcherId",
3465 "downstream_actor_id",
3466 "downstreamActorId",
3467 ];
3468
3469 #[allow(clippy::enum_variant_names)]
3470 enum GeneratedField {
3471 Type,
3472 DistKeyIndices,
3473 OutputMapping,
3474 HashMapping,
3475 DispatcherId,
3476 DownstreamActorId,
3477 }
3478 impl<'de> serde::Deserialize<'de> for GeneratedField {
3479 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3480 where
3481 D: serde::Deserializer<'de>,
3482 {
3483 struct GeneratedVisitor;
3484
3485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3486 type Value = GeneratedField;
3487
3488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3489 write!(formatter, "expected one of: {:?}", &FIELDS)
3490 }
3491
3492 #[allow(unused_variables)]
3493 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3494 where
3495 E: serde::de::Error,
3496 {
3497 match value {
3498 "type" => Ok(GeneratedField::Type),
3499 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3500 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3501 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3502 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3503 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3505 }
3506 }
3507 }
3508 deserializer.deserialize_identifier(GeneratedVisitor)
3509 }
3510 }
3511 struct GeneratedVisitor;
3512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3513 type Value = Dispatcher;
3514
3515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3516 formatter.write_str("struct stream_plan.Dispatcher")
3517 }
3518
3519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3520 where
3521 V: serde::de::MapAccess<'de>,
3522 {
3523 let mut r#type__ = None;
3524 let mut dist_key_indices__ = None;
3525 let mut output_mapping__ = None;
3526 let mut hash_mapping__ = None;
3527 let mut dispatcher_id__ = None;
3528 let mut downstream_actor_id__ = None;
3529 while let Some(k) = map_.next_key()? {
3530 match k {
3531 GeneratedField::Type => {
3532 if r#type__.is_some() {
3533 return Err(serde::de::Error::duplicate_field("type"));
3534 }
3535 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3536 }
3537 GeneratedField::DistKeyIndices => {
3538 if dist_key_indices__.is_some() {
3539 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3540 }
3541 dist_key_indices__ =
3542 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3543 .into_iter().map(|x| x.0).collect())
3544 ;
3545 }
3546 GeneratedField::OutputMapping => {
3547 if output_mapping__.is_some() {
3548 return Err(serde::de::Error::duplicate_field("outputMapping"));
3549 }
3550 output_mapping__ = map_.next_value()?;
3551 }
3552 GeneratedField::HashMapping => {
3553 if hash_mapping__.is_some() {
3554 return Err(serde::de::Error::duplicate_field("hashMapping"));
3555 }
3556 hash_mapping__ = map_.next_value()?;
3557 }
3558 GeneratedField::DispatcherId => {
3559 if dispatcher_id__.is_some() {
3560 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3561 }
3562 dispatcher_id__ =
3563 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3564 ;
3565 }
3566 GeneratedField::DownstreamActorId => {
3567 if downstream_actor_id__.is_some() {
3568 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3569 }
3570 downstream_actor_id__ =
3571 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3572 .into_iter().map(|x| x.0).collect())
3573 ;
3574 }
3575 }
3576 }
3577 Ok(Dispatcher {
3578 r#type: r#type__.unwrap_or_default(),
3579 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3580 output_mapping: output_mapping__,
3581 hash_mapping: hash_mapping__,
3582 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3583 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3584 })
3585 }
3586 }
3587 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3588 }
3589}
3590impl serde::Serialize for DispatcherType {
3591 #[allow(deprecated)]
3592 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3593 where
3594 S: serde::Serializer,
3595 {
3596 let variant = match self {
3597 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3598 Self::Hash => "DISPATCHER_TYPE_HASH",
3599 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3600 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3601 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3602 };
3603 serializer.serialize_str(variant)
3604 }
3605}
3606impl<'de> serde::Deserialize<'de> for DispatcherType {
3607 #[allow(deprecated)]
3608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3609 where
3610 D: serde::Deserializer<'de>,
3611 {
3612 const FIELDS: &[&str] = &[
3613 "DISPATCHER_TYPE_UNSPECIFIED",
3614 "DISPATCHER_TYPE_HASH",
3615 "DISPATCHER_TYPE_BROADCAST",
3616 "DISPATCHER_TYPE_SIMPLE",
3617 "DISPATCHER_TYPE_NO_SHUFFLE",
3618 ];
3619
3620 struct GeneratedVisitor;
3621
3622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3623 type Value = DispatcherType;
3624
3625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3626 write!(formatter, "expected one of: {:?}", &FIELDS)
3627 }
3628
3629 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3630 where
3631 E: serde::de::Error,
3632 {
3633 i32::try_from(v)
3634 .ok()
3635 .and_then(|x| x.try_into().ok())
3636 .ok_or_else(|| {
3637 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3638 })
3639 }
3640
3641 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3642 where
3643 E: serde::de::Error,
3644 {
3645 i32::try_from(v)
3646 .ok()
3647 .and_then(|x| x.try_into().ok())
3648 .ok_or_else(|| {
3649 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3650 })
3651 }
3652
3653 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3654 where
3655 E: serde::de::Error,
3656 {
3657 match value {
3658 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3659 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3660 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3661 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3662 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3663 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3664 }
3665 }
3666 }
3667 deserializer.deserialize_any(GeneratedVisitor)
3668 }
3669}
3670impl serde::Serialize for Dispatchers {
3671 #[allow(deprecated)]
3672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3673 where
3674 S: serde::Serializer,
3675 {
3676 use serde::ser::SerializeStruct;
3677 let mut len = 0;
3678 if !self.dispatchers.is_empty() {
3679 len += 1;
3680 }
3681 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3682 if !self.dispatchers.is_empty() {
3683 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3684 }
3685 struct_ser.end()
3686 }
3687}
3688impl<'de> serde::Deserialize<'de> for Dispatchers {
3689 #[allow(deprecated)]
3690 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3691 where
3692 D: serde::Deserializer<'de>,
3693 {
3694 const FIELDS: &[&str] = &[
3695 "dispatchers",
3696 ];
3697
3698 #[allow(clippy::enum_variant_names)]
3699 enum GeneratedField {
3700 Dispatchers,
3701 }
3702 impl<'de> serde::Deserialize<'de> for GeneratedField {
3703 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3704 where
3705 D: serde::Deserializer<'de>,
3706 {
3707 struct GeneratedVisitor;
3708
3709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3710 type Value = GeneratedField;
3711
3712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3713 write!(formatter, "expected one of: {:?}", &FIELDS)
3714 }
3715
3716 #[allow(unused_variables)]
3717 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3718 where
3719 E: serde::de::Error,
3720 {
3721 match value {
3722 "dispatchers" => Ok(GeneratedField::Dispatchers),
3723 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3724 }
3725 }
3726 }
3727 deserializer.deserialize_identifier(GeneratedVisitor)
3728 }
3729 }
3730 struct GeneratedVisitor;
3731 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3732 type Value = Dispatchers;
3733
3734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3735 formatter.write_str("struct stream_plan.Dispatchers")
3736 }
3737
3738 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3739 where
3740 V: serde::de::MapAccess<'de>,
3741 {
3742 let mut dispatchers__ = None;
3743 while let Some(k) = map_.next_key()? {
3744 match k {
3745 GeneratedField::Dispatchers => {
3746 if dispatchers__.is_some() {
3747 return Err(serde::de::Error::duplicate_field("dispatchers"));
3748 }
3749 dispatchers__ = Some(map_.next_value()?);
3750 }
3751 }
3752 }
3753 Ok(Dispatchers {
3754 dispatchers: dispatchers__.unwrap_or_default(),
3755 })
3756 }
3757 }
3758 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3759 }
3760}
3761impl serde::Serialize for DmlNode {
3762 #[allow(deprecated)]
3763 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3764 where
3765 S: serde::Serializer,
3766 {
3767 use serde::ser::SerializeStruct;
3768 let mut len = 0;
3769 if self.table_id != 0 {
3770 len += 1;
3771 }
3772 if self.table_version_id != 0 {
3773 len += 1;
3774 }
3775 if !self.column_descs.is_empty() {
3776 len += 1;
3777 }
3778 if self.rate_limit.is_some() {
3779 len += 1;
3780 }
3781 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3782 if self.table_id != 0 {
3783 struct_ser.serialize_field("tableId", &self.table_id)?;
3784 }
3785 if self.table_version_id != 0 {
3786 #[allow(clippy::needless_borrow)]
3787 #[allow(clippy::needless_borrows_for_generic_args)]
3788 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3789 }
3790 if !self.column_descs.is_empty() {
3791 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3792 }
3793 if let Some(v) = self.rate_limit.as_ref() {
3794 struct_ser.serialize_field("rateLimit", v)?;
3795 }
3796 struct_ser.end()
3797 }
3798}
3799impl<'de> serde::Deserialize<'de> for DmlNode {
3800 #[allow(deprecated)]
3801 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3802 where
3803 D: serde::Deserializer<'de>,
3804 {
3805 const FIELDS: &[&str] = &[
3806 "table_id",
3807 "tableId",
3808 "table_version_id",
3809 "tableVersionId",
3810 "column_descs",
3811 "columnDescs",
3812 "rate_limit",
3813 "rateLimit",
3814 ];
3815
3816 #[allow(clippy::enum_variant_names)]
3817 enum GeneratedField {
3818 TableId,
3819 TableVersionId,
3820 ColumnDescs,
3821 RateLimit,
3822 }
3823 impl<'de> serde::Deserialize<'de> for GeneratedField {
3824 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3825 where
3826 D: serde::Deserializer<'de>,
3827 {
3828 struct GeneratedVisitor;
3829
3830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3831 type Value = GeneratedField;
3832
3833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3834 write!(formatter, "expected one of: {:?}", &FIELDS)
3835 }
3836
3837 #[allow(unused_variables)]
3838 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3839 where
3840 E: serde::de::Error,
3841 {
3842 match value {
3843 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3844 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3845 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3846 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3848 }
3849 }
3850 }
3851 deserializer.deserialize_identifier(GeneratedVisitor)
3852 }
3853 }
3854 struct GeneratedVisitor;
3855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3856 type Value = DmlNode;
3857
3858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3859 formatter.write_str("struct stream_plan.DmlNode")
3860 }
3861
3862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
3863 where
3864 V: serde::de::MapAccess<'de>,
3865 {
3866 let mut table_id__ = None;
3867 let mut table_version_id__ = None;
3868 let mut column_descs__ = None;
3869 let mut rate_limit__ = None;
3870 while let Some(k) = map_.next_key()? {
3871 match k {
3872 GeneratedField::TableId => {
3873 if table_id__.is_some() {
3874 return Err(serde::de::Error::duplicate_field("tableId"));
3875 }
3876 table_id__ =
3877 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3878 ;
3879 }
3880 GeneratedField::TableVersionId => {
3881 if table_version_id__.is_some() {
3882 return Err(serde::de::Error::duplicate_field("tableVersionId"));
3883 }
3884 table_version_id__ =
3885 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3886 ;
3887 }
3888 GeneratedField::ColumnDescs => {
3889 if column_descs__.is_some() {
3890 return Err(serde::de::Error::duplicate_field("columnDescs"));
3891 }
3892 column_descs__ = Some(map_.next_value()?);
3893 }
3894 GeneratedField::RateLimit => {
3895 if rate_limit__.is_some() {
3896 return Err(serde::de::Error::duplicate_field("rateLimit"));
3897 }
3898 rate_limit__ =
3899 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3900 ;
3901 }
3902 }
3903 }
3904 Ok(DmlNode {
3905 table_id: table_id__.unwrap_or_default(),
3906 table_version_id: table_version_id__.unwrap_or_default(),
3907 column_descs: column_descs__.unwrap_or_default(),
3908 rate_limit: rate_limit__,
3909 })
3910 }
3911 }
3912 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
3913 }
3914}
3915impl serde::Serialize for DropSubscriptionsMutation {
3916 #[allow(deprecated)]
3917 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3918 where
3919 S: serde::Serializer,
3920 {
3921 use serde::ser::SerializeStruct;
3922 let mut len = 0;
3923 if !self.info.is_empty() {
3924 len += 1;
3925 }
3926 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
3927 if !self.info.is_empty() {
3928 struct_ser.serialize_field("info", &self.info)?;
3929 }
3930 struct_ser.end()
3931 }
3932}
3933impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
3934 #[allow(deprecated)]
3935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3936 where
3937 D: serde::Deserializer<'de>,
3938 {
3939 const FIELDS: &[&str] = &[
3940 "info",
3941 ];
3942
3943 #[allow(clippy::enum_variant_names)]
3944 enum GeneratedField {
3945 Info,
3946 }
3947 impl<'de> serde::Deserialize<'de> for GeneratedField {
3948 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3949 where
3950 D: serde::Deserializer<'de>,
3951 {
3952 struct GeneratedVisitor;
3953
3954 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3955 type Value = GeneratedField;
3956
3957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3958 write!(formatter, "expected one of: {:?}", &FIELDS)
3959 }
3960
3961 #[allow(unused_variables)]
3962 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3963 where
3964 E: serde::de::Error,
3965 {
3966 match value {
3967 "info" => Ok(GeneratedField::Info),
3968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3969 }
3970 }
3971 }
3972 deserializer.deserialize_identifier(GeneratedVisitor)
3973 }
3974 }
3975 struct GeneratedVisitor;
3976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3977 type Value = DropSubscriptionsMutation;
3978
3979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3980 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
3981 }
3982
3983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
3984 where
3985 V: serde::de::MapAccess<'de>,
3986 {
3987 let mut info__ = None;
3988 while let Some(k) = map_.next_key()? {
3989 match k {
3990 GeneratedField::Info => {
3991 if info__.is_some() {
3992 return Err(serde::de::Error::duplicate_field("info"));
3993 }
3994 info__ = Some(map_.next_value()?);
3995 }
3996 }
3997 }
3998 Ok(DropSubscriptionsMutation {
3999 info: info__.unwrap_or_default(),
4000 })
4001 }
4002 }
4003 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4004 }
4005}
4006impl serde::Serialize for DynamicFilterNode {
4007 #[allow(deprecated)]
4008 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4009 where
4010 S: serde::Serializer,
4011 {
4012 use serde::ser::SerializeStruct;
4013 let mut len = 0;
4014 if self.left_key != 0 {
4015 len += 1;
4016 }
4017 if self.condition.is_some() {
4018 len += 1;
4019 }
4020 if self.left_table.is_some() {
4021 len += 1;
4022 }
4023 if self.right_table.is_some() {
4024 len += 1;
4025 }
4026 if self.condition_always_relax {
4027 len += 1;
4028 }
4029 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4030 if self.left_key != 0 {
4031 struct_ser.serialize_field("leftKey", &self.left_key)?;
4032 }
4033 if let Some(v) = self.condition.as_ref() {
4034 struct_ser.serialize_field("condition", v)?;
4035 }
4036 if let Some(v) = self.left_table.as_ref() {
4037 struct_ser.serialize_field("leftTable", v)?;
4038 }
4039 if let Some(v) = self.right_table.as_ref() {
4040 struct_ser.serialize_field("rightTable", v)?;
4041 }
4042 if self.condition_always_relax {
4043 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4044 }
4045 struct_ser.end()
4046 }
4047}
4048impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4049 #[allow(deprecated)]
4050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4051 where
4052 D: serde::Deserializer<'de>,
4053 {
4054 const FIELDS: &[&str] = &[
4055 "left_key",
4056 "leftKey",
4057 "condition",
4058 "left_table",
4059 "leftTable",
4060 "right_table",
4061 "rightTable",
4062 "condition_always_relax",
4063 "conditionAlwaysRelax",
4064 ];
4065
4066 #[allow(clippy::enum_variant_names)]
4067 enum GeneratedField {
4068 LeftKey,
4069 Condition,
4070 LeftTable,
4071 RightTable,
4072 ConditionAlwaysRelax,
4073 }
4074 impl<'de> serde::Deserialize<'de> for GeneratedField {
4075 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4076 where
4077 D: serde::Deserializer<'de>,
4078 {
4079 struct GeneratedVisitor;
4080
4081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4082 type Value = GeneratedField;
4083
4084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4085 write!(formatter, "expected one of: {:?}", &FIELDS)
4086 }
4087
4088 #[allow(unused_variables)]
4089 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4090 where
4091 E: serde::de::Error,
4092 {
4093 match value {
4094 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4095 "condition" => Ok(GeneratedField::Condition),
4096 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4097 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4098 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4099 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4100 }
4101 }
4102 }
4103 deserializer.deserialize_identifier(GeneratedVisitor)
4104 }
4105 }
4106 struct GeneratedVisitor;
4107 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4108 type Value = DynamicFilterNode;
4109
4110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4111 formatter.write_str("struct stream_plan.DynamicFilterNode")
4112 }
4113
4114 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4115 where
4116 V: serde::de::MapAccess<'de>,
4117 {
4118 let mut left_key__ = None;
4119 let mut condition__ = None;
4120 let mut left_table__ = None;
4121 let mut right_table__ = None;
4122 let mut condition_always_relax__ = None;
4123 while let Some(k) = map_.next_key()? {
4124 match k {
4125 GeneratedField::LeftKey => {
4126 if left_key__.is_some() {
4127 return Err(serde::de::Error::duplicate_field("leftKey"));
4128 }
4129 left_key__ =
4130 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4131 ;
4132 }
4133 GeneratedField::Condition => {
4134 if condition__.is_some() {
4135 return Err(serde::de::Error::duplicate_field("condition"));
4136 }
4137 condition__ = map_.next_value()?;
4138 }
4139 GeneratedField::LeftTable => {
4140 if left_table__.is_some() {
4141 return Err(serde::de::Error::duplicate_field("leftTable"));
4142 }
4143 left_table__ = map_.next_value()?;
4144 }
4145 GeneratedField::RightTable => {
4146 if right_table__.is_some() {
4147 return Err(serde::de::Error::duplicate_field("rightTable"));
4148 }
4149 right_table__ = map_.next_value()?;
4150 }
4151 GeneratedField::ConditionAlwaysRelax => {
4152 if condition_always_relax__.is_some() {
4153 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4154 }
4155 condition_always_relax__ = Some(map_.next_value()?);
4156 }
4157 }
4158 }
4159 Ok(DynamicFilterNode {
4160 left_key: left_key__.unwrap_or_default(),
4161 condition: condition__,
4162 left_table: left_table__,
4163 right_table: right_table__,
4164 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4165 })
4166 }
4167 }
4168 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4169 }
4170}
4171impl serde::Serialize for EowcOverWindowNode {
4172 #[allow(deprecated)]
4173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4174 where
4175 S: serde::Serializer,
4176 {
4177 use serde::ser::SerializeStruct;
4178 let mut len = 0;
4179 if !self.calls.is_empty() {
4180 len += 1;
4181 }
4182 if !self.partition_by.is_empty() {
4183 len += 1;
4184 }
4185 if !self.order_by.is_empty() {
4186 len += 1;
4187 }
4188 if self.state_table.is_some() {
4189 len += 1;
4190 }
4191 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4192 if !self.calls.is_empty() {
4193 struct_ser.serialize_field("calls", &self.calls)?;
4194 }
4195 if !self.partition_by.is_empty() {
4196 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4197 }
4198 if !self.order_by.is_empty() {
4199 struct_ser.serialize_field("orderBy", &self.order_by)?;
4200 }
4201 if let Some(v) = self.state_table.as_ref() {
4202 struct_ser.serialize_field("stateTable", v)?;
4203 }
4204 struct_ser.end()
4205 }
4206}
4207impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4208 #[allow(deprecated)]
4209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4210 where
4211 D: serde::Deserializer<'de>,
4212 {
4213 const FIELDS: &[&str] = &[
4214 "calls",
4215 "partition_by",
4216 "partitionBy",
4217 "order_by",
4218 "orderBy",
4219 "state_table",
4220 "stateTable",
4221 ];
4222
4223 #[allow(clippy::enum_variant_names)]
4224 enum GeneratedField {
4225 Calls,
4226 PartitionBy,
4227 OrderBy,
4228 StateTable,
4229 }
4230 impl<'de> serde::Deserialize<'de> for GeneratedField {
4231 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4232 where
4233 D: serde::Deserializer<'de>,
4234 {
4235 struct GeneratedVisitor;
4236
4237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4238 type Value = GeneratedField;
4239
4240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4241 write!(formatter, "expected one of: {:?}", &FIELDS)
4242 }
4243
4244 #[allow(unused_variables)]
4245 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4246 where
4247 E: serde::de::Error,
4248 {
4249 match value {
4250 "calls" => Ok(GeneratedField::Calls),
4251 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4252 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4253 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4254 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4255 }
4256 }
4257 }
4258 deserializer.deserialize_identifier(GeneratedVisitor)
4259 }
4260 }
4261 struct GeneratedVisitor;
4262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4263 type Value = EowcOverWindowNode;
4264
4265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4266 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4267 }
4268
4269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4270 where
4271 V: serde::de::MapAccess<'de>,
4272 {
4273 let mut calls__ = None;
4274 let mut partition_by__ = None;
4275 let mut order_by__ = None;
4276 let mut state_table__ = None;
4277 while let Some(k) = map_.next_key()? {
4278 match k {
4279 GeneratedField::Calls => {
4280 if calls__.is_some() {
4281 return Err(serde::de::Error::duplicate_field("calls"));
4282 }
4283 calls__ = Some(map_.next_value()?);
4284 }
4285 GeneratedField::PartitionBy => {
4286 if partition_by__.is_some() {
4287 return Err(serde::de::Error::duplicate_field("partitionBy"));
4288 }
4289 partition_by__ =
4290 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4291 .into_iter().map(|x| x.0).collect())
4292 ;
4293 }
4294 GeneratedField::OrderBy => {
4295 if order_by__.is_some() {
4296 return Err(serde::de::Error::duplicate_field("orderBy"));
4297 }
4298 order_by__ = Some(map_.next_value()?);
4299 }
4300 GeneratedField::StateTable => {
4301 if state_table__.is_some() {
4302 return Err(serde::de::Error::duplicate_field("stateTable"));
4303 }
4304 state_table__ = map_.next_value()?;
4305 }
4306 }
4307 }
4308 Ok(EowcOverWindowNode {
4309 calls: calls__.unwrap_or_default(),
4310 partition_by: partition_by__.unwrap_or_default(),
4311 order_by: order_by__.unwrap_or_default(),
4312 state_table: state_table__,
4313 })
4314 }
4315 }
4316 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4317 }
4318}
4319impl serde::Serialize for ExchangeNode {
4320 #[allow(deprecated)]
4321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4322 where
4323 S: serde::Serializer,
4324 {
4325 use serde::ser::SerializeStruct;
4326 let mut len = 0;
4327 if self.strategy.is_some() {
4328 len += 1;
4329 }
4330 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4331 if let Some(v) = self.strategy.as_ref() {
4332 struct_ser.serialize_field("strategy", v)?;
4333 }
4334 struct_ser.end()
4335 }
4336}
4337impl<'de> serde::Deserialize<'de> for ExchangeNode {
4338 #[allow(deprecated)]
4339 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4340 where
4341 D: serde::Deserializer<'de>,
4342 {
4343 const FIELDS: &[&str] = &[
4344 "strategy",
4345 ];
4346
4347 #[allow(clippy::enum_variant_names)]
4348 enum GeneratedField {
4349 Strategy,
4350 }
4351 impl<'de> serde::Deserialize<'de> for GeneratedField {
4352 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4353 where
4354 D: serde::Deserializer<'de>,
4355 {
4356 struct GeneratedVisitor;
4357
4358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4359 type Value = GeneratedField;
4360
4361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4362 write!(formatter, "expected one of: {:?}", &FIELDS)
4363 }
4364
4365 #[allow(unused_variables)]
4366 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4367 where
4368 E: serde::de::Error,
4369 {
4370 match value {
4371 "strategy" => Ok(GeneratedField::Strategy),
4372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4373 }
4374 }
4375 }
4376 deserializer.deserialize_identifier(GeneratedVisitor)
4377 }
4378 }
4379 struct GeneratedVisitor;
4380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4381 type Value = ExchangeNode;
4382
4383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4384 formatter.write_str("struct stream_plan.ExchangeNode")
4385 }
4386
4387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4388 where
4389 V: serde::de::MapAccess<'de>,
4390 {
4391 let mut strategy__ = None;
4392 while let Some(k) = map_.next_key()? {
4393 match k {
4394 GeneratedField::Strategy => {
4395 if strategy__.is_some() {
4396 return Err(serde::de::Error::duplicate_field("strategy"));
4397 }
4398 strategy__ = map_.next_value()?;
4399 }
4400 }
4401 }
4402 Ok(ExchangeNode {
4403 strategy: strategy__,
4404 })
4405 }
4406 }
4407 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4408 }
4409}
4410impl serde::Serialize for ExpandNode {
4411 #[allow(deprecated)]
4412 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4413 where
4414 S: serde::Serializer,
4415 {
4416 use serde::ser::SerializeStruct;
4417 let mut len = 0;
4418 if !self.column_subsets.is_empty() {
4419 len += 1;
4420 }
4421 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4422 if !self.column_subsets.is_empty() {
4423 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4424 }
4425 struct_ser.end()
4426 }
4427}
4428impl<'de> serde::Deserialize<'de> for ExpandNode {
4429 #[allow(deprecated)]
4430 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4431 where
4432 D: serde::Deserializer<'de>,
4433 {
4434 const FIELDS: &[&str] = &[
4435 "column_subsets",
4436 "columnSubsets",
4437 ];
4438
4439 #[allow(clippy::enum_variant_names)]
4440 enum GeneratedField {
4441 ColumnSubsets,
4442 }
4443 impl<'de> serde::Deserialize<'de> for GeneratedField {
4444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4445 where
4446 D: serde::Deserializer<'de>,
4447 {
4448 struct GeneratedVisitor;
4449
4450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4451 type Value = GeneratedField;
4452
4453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4454 write!(formatter, "expected one of: {:?}", &FIELDS)
4455 }
4456
4457 #[allow(unused_variables)]
4458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4459 where
4460 E: serde::de::Error,
4461 {
4462 match value {
4463 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4464 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4465 }
4466 }
4467 }
4468 deserializer.deserialize_identifier(GeneratedVisitor)
4469 }
4470 }
4471 struct GeneratedVisitor;
4472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4473 type Value = ExpandNode;
4474
4475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4476 formatter.write_str("struct stream_plan.ExpandNode")
4477 }
4478
4479 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4480 where
4481 V: serde::de::MapAccess<'de>,
4482 {
4483 let mut column_subsets__ = None;
4484 while let Some(k) = map_.next_key()? {
4485 match k {
4486 GeneratedField::ColumnSubsets => {
4487 if column_subsets__.is_some() {
4488 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4489 }
4490 column_subsets__ = Some(map_.next_value()?);
4491 }
4492 }
4493 }
4494 Ok(ExpandNode {
4495 column_subsets: column_subsets__.unwrap_or_default(),
4496 })
4497 }
4498 }
4499 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4500 }
4501}
4502impl serde::Serialize for expand_node::Subset {
4503 #[allow(deprecated)]
4504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4505 where
4506 S: serde::Serializer,
4507 {
4508 use serde::ser::SerializeStruct;
4509 let mut len = 0;
4510 if !self.column_indices.is_empty() {
4511 len += 1;
4512 }
4513 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4514 if !self.column_indices.is_empty() {
4515 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4516 }
4517 struct_ser.end()
4518 }
4519}
4520impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4521 #[allow(deprecated)]
4522 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4523 where
4524 D: serde::Deserializer<'de>,
4525 {
4526 const FIELDS: &[&str] = &[
4527 "column_indices",
4528 "columnIndices",
4529 ];
4530
4531 #[allow(clippy::enum_variant_names)]
4532 enum GeneratedField {
4533 ColumnIndices,
4534 }
4535 impl<'de> serde::Deserialize<'de> for GeneratedField {
4536 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4537 where
4538 D: serde::Deserializer<'de>,
4539 {
4540 struct GeneratedVisitor;
4541
4542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4543 type Value = GeneratedField;
4544
4545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4546 write!(formatter, "expected one of: {:?}", &FIELDS)
4547 }
4548
4549 #[allow(unused_variables)]
4550 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4551 where
4552 E: serde::de::Error,
4553 {
4554 match value {
4555 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4556 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4557 }
4558 }
4559 }
4560 deserializer.deserialize_identifier(GeneratedVisitor)
4561 }
4562 }
4563 struct GeneratedVisitor;
4564 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4565 type Value = expand_node::Subset;
4566
4567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4568 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4569 }
4570
4571 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4572 where
4573 V: serde::de::MapAccess<'de>,
4574 {
4575 let mut column_indices__ = None;
4576 while let Some(k) = map_.next_key()? {
4577 match k {
4578 GeneratedField::ColumnIndices => {
4579 if column_indices__.is_some() {
4580 return Err(serde::de::Error::duplicate_field("columnIndices"));
4581 }
4582 column_indices__ =
4583 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4584 .into_iter().map(|x| x.0).collect())
4585 ;
4586 }
4587 }
4588 }
4589 Ok(expand_node::Subset {
4590 column_indices: column_indices__.unwrap_or_default(),
4591 })
4592 }
4593 }
4594 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4595 }
4596}
4597impl serde::Serialize for FilterNode {
4598 #[allow(deprecated)]
4599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4600 where
4601 S: serde::Serializer,
4602 {
4603 use serde::ser::SerializeStruct;
4604 let mut len = 0;
4605 if self.search_condition.is_some() {
4606 len += 1;
4607 }
4608 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4609 if let Some(v) = self.search_condition.as_ref() {
4610 struct_ser.serialize_field("searchCondition", v)?;
4611 }
4612 struct_ser.end()
4613 }
4614}
4615impl<'de> serde::Deserialize<'de> for FilterNode {
4616 #[allow(deprecated)]
4617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4618 where
4619 D: serde::Deserializer<'de>,
4620 {
4621 const FIELDS: &[&str] = &[
4622 "search_condition",
4623 "searchCondition",
4624 ];
4625
4626 #[allow(clippy::enum_variant_names)]
4627 enum GeneratedField {
4628 SearchCondition,
4629 }
4630 impl<'de> serde::Deserialize<'de> for GeneratedField {
4631 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4632 where
4633 D: serde::Deserializer<'de>,
4634 {
4635 struct GeneratedVisitor;
4636
4637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4638 type Value = GeneratedField;
4639
4640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4641 write!(formatter, "expected one of: {:?}", &FIELDS)
4642 }
4643
4644 #[allow(unused_variables)]
4645 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4646 where
4647 E: serde::de::Error,
4648 {
4649 match value {
4650 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4652 }
4653 }
4654 }
4655 deserializer.deserialize_identifier(GeneratedVisitor)
4656 }
4657 }
4658 struct GeneratedVisitor;
4659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4660 type Value = FilterNode;
4661
4662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4663 formatter.write_str("struct stream_plan.FilterNode")
4664 }
4665
4666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4667 where
4668 V: serde::de::MapAccess<'de>,
4669 {
4670 let mut search_condition__ = None;
4671 while let Some(k) = map_.next_key()? {
4672 match k {
4673 GeneratedField::SearchCondition => {
4674 if search_condition__.is_some() {
4675 return Err(serde::de::Error::duplicate_field("searchCondition"));
4676 }
4677 search_condition__ = map_.next_value()?;
4678 }
4679 }
4680 }
4681 Ok(FilterNode {
4682 search_condition: search_condition__,
4683 })
4684 }
4685 }
4686 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4687 }
4688}
4689impl serde::Serialize for GlobalApproxPercentileNode {
4690 #[allow(deprecated)]
4691 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4692 where
4693 S: serde::Serializer,
4694 {
4695 use serde::ser::SerializeStruct;
4696 let mut len = 0;
4697 if self.base != 0. {
4698 len += 1;
4699 }
4700 if self.quantile != 0. {
4701 len += 1;
4702 }
4703 if self.bucket_state_table.is_some() {
4704 len += 1;
4705 }
4706 if self.count_state_table.is_some() {
4707 len += 1;
4708 }
4709 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4710 if self.base != 0. {
4711 struct_ser.serialize_field("base", &self.base)?;
4712 }
4713 if self.quantile != 0. {
4714 struct_ser.serialize_field("quantile", &self.quantile)?;
4715 }
4716 if let Some(v) = self.bucket_state_table.as_ref() {
4717 struct_ser.serialize_field("bucketStateTable", v)?;
4718 }
4719 if let Some(v) = self.count_state_table.as_ref() {
4720 struct_ser.serialize_field("countStateTable", v)?;
4721 }
4722 struct_ser.end()
4723 }
4724}
4725impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4726 #[allow(deprecated)]
4727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4728 where
4729 D: serde::Deserializer<'de>,
4730 {
4731 const FIELDS: &[&str] = &[
4732 "base",
4733 "quantile",
4734 "bucket_state_table",
4735 "bucketStateTable",
4736 "count_state_table",
4737 "countStateTable",
4738 ];
4739
4740 #[allow(clippy::enum_variant_names)]
4741 enum GeneratedField {
4742 Base,
4743 Quantile,
4744 BucketStateTable,
4745 CountStateTable,
4746 }
4747 impl<'de> serde::Deserialize<'de> for GeneratedField {
4748 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4749 where
4750 D: serde::Deserializer<'de>,
4751 {
4752 struct GeneratedVisitor;
4753
4754 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4755 type Value = GeneratedField;
4756
4757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4758 write!(formatter, "expected one of: {:?}", &FIELDS)
4759 }
4760
4761 #[allow(unused_variables)]
4762 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4763 where
4764 E: serde::de::Error,
4765 {
4766 match value {
4767 "base" => Ok(GeneratedField::Base),
4768 "quantile" => Ok(GeneratedField::Quantile),
4769 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4770 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4771 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4772 }
4773 }
4774 }
4775 deserializer.deserialize_identifier(GeneratedVisitor)
4776 }
4777 }
4778 struct GeneratedVisitor;
4779 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4780 type Value = GlobalApproxPercentileNode;
4781
4782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4783 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4784 }
4785
4786 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4787 where
4788 V: serde::de::MapAccess<'de>,
4789 {
4790 let mut base__ = None;
4791 let mut quantile__ = None;
4792 let mut bucket_state_table__ = None;
4793 let mut count_state_table__ = None;
4794 while let Some(k) = map_.next_key()? {
4795 match k {
4796 GeneratedField::Base => {
4797 if base__.is_some() {
4798 return Err(serde::de::Error::duplicate_field("base"));
4799 }
4800 base__ =
4801 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4802 ;
4803 }
4804 GeneratedField::Quantile => {
4805 if quantile__.is_some() {
4806 return Err(serde::de::Error::duplicate_field("quantile"));
4807 }
4808 quantile__ =
4809 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4810 ;
4811 }
4812 GeneratedField::BucketStateTable => {
4813 if bucket_state_table__.is_some() {
4814 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4815 }
4816 bucket_state_table__ = map_.next_value()?;
4817 }
4818 GeneratedField::CountStateTable => {
4819 if count_state_table__.is_some() {
4820 return Err(serde::de::Error::duplicate_field("countStateTable"));
4821 }
4822 count_state_table__ = map_.next_value()?;
4823 }
4824 }
4825 }
4826 Ok(GlobalApproxPercentileNode {
4827 base: base__.unwrap_or_default(),
4828 quantile: quantile__.unwrap_or_default(),
4829 bucket_state_table: bucket_state_table__,
4830 count_state_table: count_state_table__,
4831 })
4832 }
4833 }
4834 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4835 }
4836}
4837impl serde::Serialize for GroupTopNNode {
4838 #[allow(deprecated)]
4839 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4840 where
4841 S: serde::Serializer,
4842 {
4843 use serde::ser::SerializeStruct;
4844 let mut len = 0;
4845 if self.limit != 0 {
4846 len += 1;
4847 }
4848 if self.offset != 0 {
4849 len += 1;
4850 }
4851 if !self.group_key.is_empty() {
4852 len += 1;
4853 }
4854 if self.table.is_some() {
4855 len += 1;
4856 }
4857 if !self.order_by.is_empty() {
4858 len += 1;
4859 }
4860 if self.with_ties {
4861 len += 1;
4862 }
4863 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
4864 if self.limit != 0 {
4865 #[allow(clippy::needless_borrow)]
4866 #[allow(clippy::needless_borrows_for_generic_args)]
4867 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
4868 }
4869 if self.offset != 0 {
4870 #[allow(clippy::needless_borrow)]
4871 #[allow(clippy::needless_borrows_for_generic_args)]
4872 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
4873 }
4874 if !self.group_key.is_empty() {
4875 struct_ser.serialize_field("groupKey", &self.group_key)?;
4876 }
4877 if let Some(v) = self.table.as_ref() {
4878 struct_ser.serialize_field("table", v)?;
4879 }
4880 if !self.order_by.is_empty() {
4881 struct_ser.serialize_field("orderBy", &self.order_by)?;
4882 }
4883 if self.with_ties {
4884 struct_ser.serialize_field("withTies", &self.with_ties)?;
4885 }
4886 struct_ser.end()
4887 }
4888}
4889impl<'de> serde::Deserialize<'de> for GroupTopNNode {
4890 #[allow(deprecated)]
4891 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4892 where
4893 D: serde::Deserializer<'de>,
4894 {
4895 const FIELDS: &[&str] = &[
4896 "limit",
4897 "offset",
4898 "group_key",
4899 "groupKey",
4900 "table",
4901 "order_by",
4902 "orderBy",
4903 "with_ties",
4904 "withTies",
4905 ];
4906
4907 #[allow(clippy::enum_variant_names)]
4908 enum GeneratedField {
4909 Limit,
4910 Offset,
4911 GroupKey,
4912 Table,
4913 OrderBy,
4914 WithTies,
4915 }
4916 impl<'de> serde::Deserialize<'de> for GeneratedField {
4917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4918 where
4919 D: serde::Deserializer<'de>,
4920 {
4921 struct GeneratedVisitor;
4922
4923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4924 type Value = GeneratedField;
4925
4926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4927 write!(formatter, "expected one of: {:?}", &FIELDS)
4928 }
4929
4930 #[allow(unused_variables)]
4931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4932 where
4933 E: serde::de::Error,
4934 {
4935 match value {
4936 "limit" => Ok(GeneratedField::Limit),
4937 "offset" => Ok(GeneratedField::Offset),
4938 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
4939 "table" => Ok(GeneratedField::Table),
4940 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4941 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
4942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4943 }
4944 }
4945 }
4946 deserializer.deserialize_identifier(GeneratedVisitor)
4947 }
4948 }
4949 struct GeneratedVisitor;
4950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4951 type Value = GroupTopNNode;
4952
4953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4954 formatter.write_str("struct stream_plan.GroupTopNNode")
4955 }
4956
4957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
4958 where
4959 V: serde::de::MapAccess<'de>,
4960 {
4961 let mut limit__ = None;
4962 let mut offset__ = None;
4963 let mut group_key__ = None;
4964 let mut table__ = None;
4965 let mut order_by__ = None;
4966 let mut with_ties__ = None;
4967 while let Some(k) = map_.next_key()? {
4968 match k {
4969 GeneratedField::Limit => {
4970 if limit__.is_some() {
4971 return Err(serde::de::Error::duplicate_field("limit"));
4972 }
4973 limit__ =
4974 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4975 ;
4976 }
4977 GeneratedField::Offset => {
4978 if offset__.is_some() {
4979 return Err(serde::de::Error::duplicate_field("offset"));
4980 }
4981 offset__ =
4982 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4983 ;
4984 }
4985 GeneratedField::GroupKey => {
4986 if group_key__.is_some() {
4987 return Err(serde::de::Error::duplicate_field("groupKey"));
4988 }
4989 group_key__ =
4990 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4991 .into_iter().map(|x| x.0).collect())
4992 ;
4993 }
4994 GeneratedField::Table => {
4995 if table__.is_some() {
4996 return Err(serde::de::Error::duplicate_field("table"));
4997 }
4998 table__ = map_.next_value()?;
4999 }
5000 GeneratedField::OrderBy => {
5001 if order_by__.is_some() {
5002 return Err(serde::de::Error::duplicate_field("orderBy"));
5003 }
5004 order_by__ = Some(map_.next_value()?);
5005 }
5006 GeneratedField::WithTies => {
5007 if with_ties__.is_some() {
5008 return Err(serde::de::Error::duplicate_field("withTies"));
5009 }
5010 with_ties__ = Some(map_.next_value()?);
5011 }
5012 }
5013 }
5014 Ok(GroupTopNNode {
5015 limit: limit__.unwrap_or_default(),
5016 offset: offset__.unwrap_or_default(),
5017 group_key: group_key__.unwrap_or_default(),
5018 table: table__,
5019 order_by: order_by__.unwrap_or_default(),
5020 with_ties: with_ties__.unwrap_or_default(),
5021 })
5022 }
5023 }
5024 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5025 }
5026}
5027impl serde::Serialize for HashAggNode {
5028 #[allow(deprecated)]
5029 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5030 where
5031 S: serde::Serializer,
5032 {
5033 use serde::ser::SerializeStruct;
5034 let mut len = 0;
5035 if !self.group_key.is_empty() {
5036 len += 1;
5037 }
5038 if !self.agg_calls.is_empty() {
5039 len += 1;
5040 }
5041 if !self.agg_call_states.is_empty() {
5042 len += 1;
5043 }
5044 if self.intermediate_state_table.is_some() {
5045 len += 1;
5046 }
5047 if self.is_append_only {
5048 len += 1;
5049 }
5050 if !self.distinct_dedup_tables.is_empty() {
5051 len += 1;
5052 }
5053 if self.row_count_index != 0 {
5054 len += 1;
5055 }
5056 if self.emit_on_window_close {
5057 len += 1;
5058 }
5059 if self.version != 0 {
5060 len += 1;
5061 }
5062 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5063 if !self.group_key.is_empty() {
5064 struct_ser.serialize_field("groupKey", &self.group_key)?;
5065 }
5066 if !self.agg_calls.is_empty() {
5067 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5068 }
5069 if !self.agg_call_states.is_empty() {
5070 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5071 }
5072 if let Some(v) = self.intermediate_state_table.as_ref() {
5073 struct_ser.serialize_field("intermediateStateTable", v)?;
5074 }
5075 if self.is_append_only {
5076 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5077 }
5078 if !self.distinct_dedup_tables.is_empty() {
5079 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5080 }
5081 if self.row_count_index != 0 {
5082 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5083 }
5084 if self.emit_on_window_close {
5085 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5086 }
5087 if self.version != 0 {
5088 let v = AggNodeVersion::try_from(self.version)
5089 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5090 struct_ser.serialize_field("version", &v)?;
5091 }
5092 struct_ser.end()
5093 }
5094}
5095impl<'de> serde::Deserialize<'de> for HashAggNode {
5096 #[allow(deprecated)]
5097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5098 where
5099 D: serde::Deserializer<'de>,
5100 {
5101 const FIELDS: &[&str] = &[
5102 "group_key",
5103 "groupKey",
5104 "agg_calls",
5105 "aggCalls",
5106 "agg_call_states",
5107 "aggCallStates",
5108 "intermediate_state_table",
5109 "intermediateStateTable",
5110 "is_append_only",
5111 "isAppendOnly",
5112 "distinct_dedup_tables",
5113 "distinctDedupTables",
5114 "row_count_index",
5115 "rowCountIndex",
5116 "emit_on_window_close",
5117 "emitOnWindowClose",
5118 "version",
5119 ];
5120
5121 #[allow(clippy::enum_variant_names)]
5122 enum GeneratedField {
5123 GroupKey,
5124 AggCalls,
5125 AggCallStates,
5126 IntermediateStateTable,
5127 IsAppendOnly,
5128 DistinctDedupTables,
5129 RowCountIndex,
5130 EmitOnWindowClose,
5131 Version,
5132 }
5133 impl<'de> serde::Deserialize<'de> for GeneratedField {
5134 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5135 where
5136 D: serde::Deserializer<'de>,
5137 {
5138 struct GeneratedVisitor;
5139
5140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5141 type Value = GeneratedField;
5142
5143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5144 write!(formatter, "expected one of: {:?}", &FIELDS)
5145 }
5146
5147 #[allow(unused_variables)]
5148 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5149 where
5150 E: serde::de::Error,
5151 {
5152 match value {
5153 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5154 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5155 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5156 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5157 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5158 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5159 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5160 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5161 "version" => Ok(GeneratedField::Version),
5162 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5163 }
5164 }
5165 }
5166 deserializer.deserialize_identifier(GeneratedVisitor)
5167 }
5168 }
5169 struct GeneratedVisitor;
5170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5171 type Value = HashAggNode;
5172
5173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5174 formatter.write_str("struct stream_plan.HashAggNode")
5175 }
5176
5177 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5178 where
5179 V: serde::de::MapAccess<'de>,
5180 {
5181 let mut group_key__ = None;
5182 let mut agg_calls__ = None;
5183 let mut agg_call_states__ = None;
5184 let mut intermediate_state_table__ = None;
5185 let mut is_append_only__ = None;
5186 let mut distinct_dedup_tables__ = None;
5187 let mut row_count_index__ = None;
5188 let mut emit_on_window_close__ = None;
5189 let mut version__ = None;
5190 while let Some(k) = map_.next_key()? {
5191 match k {
5192 GeneratedField::GroupKey => {
5193 if group_key__.is_some() {
5194 return Err(serde::de::Error::duplicate_field("groupKey"));
5195 }
5196 group_key__ =
5197 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5198 .into_iter().map(|x| x.0).collect())
5199 ;
5200 }
5201 GeneratedField::AggCalls => {
5202 if agg_calls__.is_some() {
5203 return Err(serde::de::Error::duplicate_field("aggCalls"));
5204 }
5205 agg_calls__ = Some(map_.next_value()?);
5206 }
5207 GeneratedField::AggCallStates => {
5208 if agg_call_states__.is_some() {
5209 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5210 }
5211 agg_call_states__ = Some(map_.next_value()?);
5212 }
5213 GeneratedField::IntermediateStateTable => {
5214 if intermediate_state_table__.is_some() {
5215 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5216 }
5217 intermediate_state_table__ = map_.next_value()?;
5218 }
5219 GeneratedField::IsAppendOnly => {
5220 if is_append_only__.is_some() {
5221 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5222 }
5223 is_append_only__ = Some(map_.next_value()?);
5224 }
5225 GeneratedField::DistinctDedupTables => {
5226 if distinct_dedup_tables__.is_some() {
5227 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5228 }
5229 distinct_dedup_tables__ = Some(
5230 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5231 .into_iter().map(|(k,v)| (k.0, v)).collect()
5232 );
5233 }
5234 GeneratedField::RowCountIndex => {
5235 if row_count_index__.is_some() {
5236 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5237 }
5238 row_count_index__ =
5239 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5240 ;
5241 }
5242 GeneratedField::EmitOnWindowClose => {
5243 if emit_on_window_close__.is_some() {
5244 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5245 }
5246 emit_on_window_close__ = Some(map_.next_value()?);
5247 }
5248 GeneratedField::Version => {
5249 if version__.is_some() {
5250 return Err(serde::de::Error::duplicate_field("version"));
5251 }
5252 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5253 }
5254 }
5255 }
5256 Ok(HashAggNode {
5257 group_key: group_key__.unwrap_or_default(),
5258 agg_calls: agg_calls__.unwrap_or_default(),
5259 agg_call_states: agg_call_states__.unwrap_or_default(),
5260 intermediate_state_table: intermediate_state_table__,
5261 is_append_only: is_append_only__.unwrap_or_default(),
5262 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5263 row_count_index: row_count_index__.unwrap_or_default(),
5264 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5265 version: version__.unwrap_or_default(),
5266 })
5267 }
5268 }
5269 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5270 }
5271}
5272impl serde::Serialize for HashJoinNode {
5273 #[allow(deprecated)]
5274 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5275 where
5276 S: serde::Serializer,
5277 {
5278 use serde::ser::SerializeStruct;
5279 let mut len = 0;
5280 if self.join_type != 0 {
5281 len += 1;
5282 }
5283 if !self.left_key.is_empty() {
5284 len += 1;
5285 }
5286 if !self.right_key.is_empty() {
5287 len += 1;
5288 }
5289 if self.condition.is_some() {
5290 len += 1;
5291 }
5292 if !self.inequality_pairs.is_empty() {
5293 len += 1;
5294 }
5295 if self.left_table.is_some() {
5296 len += 1;
5297 }
5298 if self.right_table.is_some() {
5299 len += 1;
5300 }
5301 if self.left_degree_table.is_some() {
5302 len += 1;
5303 }
5304 if self.right_degree_table.is_some() {
5305 len += 1;
5306 }
5307 if !self.output_indices.is_empty() {
5308 len += 1;
5309 }
5310 if !self.left_deduped_input_pk_indices.is_empty() {
5311 len += 1;
5312 }
5313 if !self.right_deduped_input_pk_indices.is_empty() {
5314 len += 1;
5315 }
5316 if !self.null_safe.is_empty() {
5317 len += 1;
5318 }
5319 if self.is_append_only {
5320 len += 1;
5321 }
5322 if self.join_encoding_type != 0 {
5323 len += 1;
5324 }
5325 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5326 if self.join_type != 0 {
5327 let v = super::plan_common::JoinType::try_from(self.join_type)
5328 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5329 struct_ser.serialize_field("joinType", &v)?;
5330 }
5331 if !self.left_key.is_empty() {
5332 struct_ser.serialize_field("leftKey", &self.left_key)?;
5333 }
5334 if !self.right_key.is_empty() {
5335 struct_ser.serialize_field("rightKey", &self.right_key)?;
5336 }
5337 if let Some(v) = self.condition.as_ref() {
5338 struct_ser.serialize_field("condition", v)?;
5339 }
5340 if !self.inequality_pairs.is_empty() {
5341 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5342 }
5343 if let Some(v) = self.left_table.as_ref() {
5344 struct_ser.serialize_field("leftTable", v)?;
5345 }
5346 if let Some(v) = self.right_table.as_ref() {
5347 struct_ser.serialize_field("rightTable", v)?;
5348 }
5349 if let Some(v) = self.left_degree_table.as_ref() {
5350 struct_ser.serialize_field("leftDegreeTable", v)?;
5351 }
5352 if let Some(v) = self.right_degree_table.as_ref() {
5353 struct_ser.serialize_field("rightDegreeTable", v)?;
5354 }
5355 if !self.output_indices.is_empty() {
5356 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5357 }
5358 if !self.left_deduped_input_pk_indices.is_empty() {
5359 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5360 }
5361 if !self.right_deduped_input_pk_indices.is_empty() {
5362 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5363 }
5364 if !self.null_safe.is_empty() {
5365 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5366 }
5367 if self.is_append_only {
5368 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5369 }
5370 if self.join_encoding_type != 0 {
5371 let v = JoinEncodingType::try_from(self.join_encoding_type)
5372 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5373 struct_ser.serialize_field("joinEncodingType", &v)?;
5374 }
5375 struct_ser.end()
5376 }
5377}
5378impl<'de> serde::Deserialize<'de> for HashJoinNode {
5379 #[allow(deprecated)]
5380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5381 where
5382 D: serde::Deserializer<'de>,
5383 {
5384 const FIELDS: &[&str] = &[
5385 "join_type",
5386 "joinType",
5387 "left_key",
5388 "leftKey",
5389 "right_key",
5390 "rightKey",
5391 "condition",
5392 "inequality_pairs",
5393 "inequalityPairs",
5394 "left_table",
5395 "leftTable",
5396 "right_table",
5397 "rightTable",
5398 "left_degree_table",
5399 "leftDegreeTable",
5400 "right_degree_table",
5401 "rightDegreeTable",
5402 "output_indices",
5403 "outputIndices",
5404 "left_deduped_input_pk_indices",
5405 "leftDedupedInputPkIndices",
5406 "right_deduped_input_pk_indices",
5407 "rightDedupedInputPkIndices",
5408 "null_safe",
5409 "nullSafe",
5410 "is_append_only",
5411 "isAppendOnly",
5412 "join_encoding_type",
5413 "joinEncodingType",
5414 ];
5415
5416 #[allow(clippy::enum_variant_names)]
5417 enum GeneratedField {
5418 JoinType,
5419 LeftKey,
5420 RightKey,
5421 Condition,
5422 InequalityPairs,
5423 LeftTable,
5424 RightTable,
5425 LeftDegreeTable,
5426 RightDegreeTable,
5427 OutputIndices,
5428 LeftDedupedInputPkIndices,
5429 RightDedupedInputPkIndices,
5430 NullSafe,
5431 IsAppendOnly,
5432 JoinEncodingType,
5433 }
5434 impl<'de> serde::Deserialize<'de> for GeneratedField {
5435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5436 where
5437 D: serde::Deserializer<'de>,
5438 {
5439 struct GeneratedVisitor;
5440
5441 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5442 type Value = GeneratedField;
5443
5444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5445 write!(formatter, "expected one of: {:?}", &FIELDS)
5446 }
5447
5448 #[allow(unused_variables)]
5449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5450 where
5451 E: serde::de::Error,
5452 {
5453 match value {
5454 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5455 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5456 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5457 "condition" => Ok(GeneratedField::Condition),
5458 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5459 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5460 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5461 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5462 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5463 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5464 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5465 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5466 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5467 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5468 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5470 }
5471 }
5472 }
5473 deserializer.deserialize_identifier(GeneratedVisitor)
5474 }
5475 }
5476 struct GeneratedVisitor;
5477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5478 type Value = HashJoinNode;
5479
5480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5481 formatter.write_str("struct stream_plan.HashJoinNode")
5482 }
5483
5484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5485 where
5486 V: serde::de::MapAccess<'de>,
5487 {
5488 let mut join_type__ = None;
5489 let mut left_key__ = None;
5490 let mut right_key__ = None;
5491 let mut condition__ = None;
5492 let mut inequality_pairs__ = None;
5493 let mut left_table__ = None;
5494 let mut right_table__ = None;
5495 let mut left_degree_table__ = None;
5496 let mut right_degree_table__ = None;
5497 let mut output_indices__ = None;
5498 let mut left_deduped_input_pk_indices__ = None;
5499 let mut right_deduped_input_pk_indices__ = None;
5500 let mut null_safe__ = None;
5501 let mut is_append_only__ = None;
5502 let mut join_encoding_type__ = None;
5503 while let Some(k) = map_.next_key()? {
5504 match k {
5505 GeneratedField::JoinType => {
5506 if join_type__.is_some() {
5507 return Err(serde::de::Error::duplicate_field("joinType"));
5508 }
5509 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5510 }
5511 GeneratedField::LeftKey => {
5512 if left_key__.is_some() {
5513 return Err(serde::de::Error::duplicate_field("leftKey"));
5514 }
5515 left_key__ =
5516 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5517 .into_iter().map(|x| x.0).collect())
5518 ;
5519 }
5520 GeneratedField::RightKey => {
5521 if right_key__.is_some() {
5522 return Err(serde::de::Error::duplicate_field("rightKey"));
5523 }
5524 right_key__ =
5525 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5526 .into_iter().map(|x| x.0).collect())
5527 ;
5528 }
5529 GeneratedField::Condition => {
5530 if condition__.is_some() {
5531 return Err(serde::de::Error::duplicate_field("condition"));
5532 }
5533 condition__ = map_.next_value()?;
5534 }
5535 GeneratedField::InequalityPairs => {
5536 if inequality_pairs__.is_some() {
5537 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5538 }
5539 inequality_pairs__ = Some(map_.next_value()?);
5540 }
5541 GeneratedField::LeftTable => {
5542 if left_table__.is_some() {
5543 return Err(serde::de::Error::duplicate_field("leftTable"));
5544 }
5545 left_table__ = map_.next_value()?;
5546 }
5547 GeneratedField::RightTable => {
5548 if right_table__.is_some() {
5549 return Err(serde::de::Error::duplicate_field("rightTable"));
5550 }
5551 right_table__ = map_.next_value()?;
5552 }
5553 GeneratedField::LeftDegreeTable => {
5554 if left_degree_table__.is_some() {
5555 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5556 }
5557 left_degree_table__ = map_.next_value()?;
5558 }
5559 GeneratedField::RightDegreeTable => {
5560 if right_degree_table__.is_some() {
5561 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5562 }
5563 right_degree_table__ = map_.next_value()?;
5564 }
5565 GeneratedField::OutputIndices => {
5566 if output_indices__.is_some() {
5567 return Err(serde::de::Error::duplicate_field("outputIndices"));
5568 }
5569 output_indices__ =
5570 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5571 .into_iter().map(|x| x.0).collect())
5572 ;
5573 }
5574 GeneratedField::LeftDedupedInputPkIndices => {
5575 if left_deduped_input_pk_indices__.is_some() {
5576 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5577 }
5578 left_deduped_input_pk_indices__ =
5579 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5580 .into_iter().map(|x| x.0).collect())
5581 ;
5582 }
5583 GeneratedField::RightDedupedInputPkIndices => {
5584 if right_deduped_input_pk_indices__.is_some() {
5585 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5586 }
5587 right_deduped_input_pk_indices__ =
5588 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5589 .into_iter().map(|x| x.0).collect())
5590 ;
5591 }
5592 GeneratedField::NullSafe => {
5593 if null_safe__.is_some() {
5594 return Err(serde::de::Error::duplicate_field("nullSafe"));
5595 }
5596 null_safe__ = Some(map_.next_value()?);
5597 }
5598 GeneratedField::IsAppendOnly => {
5599 if is_append_only__.is_some() {
5600 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5601 }
5602 is_append_only__ = Some(map_.next_value()?);
5603 }
5604 GeneratedField::JoinEncodingType => {
5605 if join_encoding_type__.is_some() {
5606 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
5607 }
5608 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
5609 }
5610 }
5611 }
5612 Ok(HashJoinNode {
5613 join_type: join_type__.unwrap_or_default(),
5614 left_key: left_key__.unwrap_or_default(),
5615 right_key: right_key__.unwrap_or_default(),
5616 condition: condition__,
5617 inequality_pairs: inequality_pairs__.unwrap_or_default(),
5618 left_table: left_table__,
5619 right_table: right_table__,
5620 left_degree_table: left_degree_table__,
5621 right_degree_table: right_degree_table__,
5622 output_indices: output_indices__.unwrap_or_default(),
5623 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5624 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5625 null_safe: null_safe__.unwrap_or_default(),
5626 is_append_only: is_append_only__.unwrap_or_default(),
5627 join_encoding_type: join_encoding_type__.unwrap_or_default(),
5628 })
5629 }
5630 }
5631 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5632 }
5633}
5634impl serde::Serialize for HopWindowNode {
5635 #[allow(deprecated)]
5636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5637 where
5638 S: serde::Serializer,
5639 {
5640 use serde::ser::SerializeStruct;
5641 let mut len = 0;
5642 if self.time_col != 0 {
5643 len += 1;
5644 }
5645 if self.window_slide.is_some() {
5646 len += 1;
5647 }
5648 if self.window_size.is_some() {
5649 len += 1;
5650 }
5651 if !self.output_indices.is_empty() {
5652 len += 1;
5653 }
5654 if !self.window_start_exprs.is_empty() {
5655 len += 1;
5656 }
5657 if !self.window_end_exprs.is_empty() {
5658 len += 1;
5659 }
5660 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5661 if self.time_col != 0 {
5662 struct_ser.serialize_field("timeCol", &self.time_col)?;
5663 }
5664 if let Some(v) = self.window_slide.as_ref() {
5665 struct_ser.serialize_field("windowSlide", v)?;
5666 }
5667 if let Some(v) = self.window_size.as_ref() {
5668 struct_ser.serialize_field("windowSize", v)?;
5669 }
5670 if !self.output_indices.is_empty() {
5671 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5672 }
5673 if !self.window_start_exprs.is_empty() {
5674 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5675 }
5676 if !self.window_end_exprs.is_empty() {
5677 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5678 }
5679 struct_ser.end()
5680 }
5681}
5682impl<'de> serde::Deserialize<'de> for HopWindowNode {
5683 #[allow(deprecated)]
5684 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5685 where
5686 D: serde::Deserializer<'de>,
5687 {
5688 const FIELDS: &[&str] = &[
5689 "time_col",
5690 "timeCol",
5691 "window_slide",
5692 "windowSlide",
5693 "window_size",
5694 "windowSize",
5695 "output_indices",
5696 "outputIndices",
5697 "window_start_exprs",
5698 "windowStartExprs",
5699 "window_end_exprs",
5700 "windowEndExprs",
5701 ];
5702
5703 #[allow(clippy::enum_variant_names)]
5704 enum GeneratedField {
5705 TimeCol,
5706 WindowSlide,
5707 WindowSize,
5708 OutputIndices,
5709 WindowStartExprs,
5710 WindowEndExprs,
5711 }
5712 impl<'de> serde::Deserialize<'de> for GeneratedField {
5713 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5714 where
5715 D: serde::Deserializer<'de>,
5716 {
5717 struct GeneratedVisitor;
5718
5719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5720 type Value = GeneratedField;
5721
5722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5723 write!(formatter, "expected one of: {:?}", &FIELDS)
5724 }
5725
5726 #[allow(unused_variables)]
5727 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5728 where
5729 E: serde::de::Error,
5730 {
5731 match value {
5732 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5733 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5734 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5735 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5736 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5737 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5738 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5739 }
5740 }
5741 }
5742 deserializer.deserialize_identifier(GeneratedVisitor)
5743 }
5744 }
5745 struct GeneratedVisitor;
5746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5747 type Value = HopWindowNode;
5748
5749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5750 formatter.write_str("struct stream_plan.HopWindowNode")
5751 }
5752
5753 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5754 where
5755 V: serde::de::MapAccess<'de>,
5756 {
5757 let mut time_col__ = None;
5758 let mut window_slide__ = None;
5759 let mut window_size__ = None;
5760 let mut output_indices__ = None;
5761 let mut window_start_exprs__ = None;
5762 let mut window_end_exprs__ = None;
5763 while let Some(k) = map_.next_key()? {
5764 match k {
5765 GeneratedField::TimeCol => {
5766 if time_col__.is_some() {
5767 return Err(serde::de::Error::duplicate_field("timeCol"));
5768 }
5769 time_col__ =
5770 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5771 ;
5772 }
5773 GeneratedField::WindowSlide => {
5774 if window_slide__.is_some() {
5775 return Err(serde::de::Error::duplicate_field("windowSlide"));
5776 }
5777 window_slide__ = map_.next_value()?;
5778 }
5779 GeneratedField::WindowSize => {
5780 if window_size__.is_some() {
5781 return Err(serde::de::Error::duplicate_field("windowSize"));
5782 }
5783 window_size__ = map_.next_value()?;
5784 }
5785 GeneratedField::OutputIndices => {
5786 if output_indices__.is_some() {
5787 return Err(serde::de::Error::duplicate_field("outputIndices"));
5788 }
5789 output_indices__ =
5790 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5791 .into_iter().map(|x| x.0).collect())
5792 ;
5793 }
5794 GeneratedField::WindowStartExprs => {
5795 if window_start_exprs__.is_some() {
5796 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5797 }
5798 window_start_exprs__ = Some(map_.next_value()?);
5799 }
5800 GeneratedField::WindowEndExprs => {
5801 if window_end_exprs__.is_some() {
5802 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5803 }
5804 window_end_exprs__ = Some(map_.next_value()?);
5805 }
5806 }
5807 }
5808 Ok(HopWindowNode {
5809 time_col: time_col__.unwrap_or_default(),
5810 window_slide: window_slide__,
5811 window_size: window_size__,
5812 output_indices: output_indices__.unwrap_or_default(),
5813 window_start_exprs: window_start_exprs__.unwrap_or_default(),
5814 window_end_exprs: window_end_exprs__.unwrap_or_default(),
5815 })
5816 }
5817 }
5818 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5819 }
5820}
5821impl serde::Serialize for InequalityPair {
5822 #[allow(deprecated)]
5823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5824 where
5825 S: serde::Serializer,
5826 {
5827 use serde::ser::SerializeStruct;
5828 let mut len = 0;
5829 if self.key_required_larger != 0 {
5830 len += 1;
5831 }
5832 if self.key_required_smaller != 0 {
5833 len += 1;
5834 }
5835 if self.clean_state {
5836 len += 1;
5837 }
5838 if self.delta_expression.is_some() {
5839 len += 1;
5840 }
5841 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5842 if self.key_required_larger != 0 {
5843 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5844 }
5845 if self.key_required_smaller != 0 {
5846 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5847 }
5848 if self.clean_state {
5849 struct_ser.serialize_field("cleanState", &self.clean_state)?;
5850 }
5851 if let Some(v) = self.delta_expression.as_ref() {
5852 struct_ser.serialize_field("deltaExpression", v)?;
5853 }
5854 struct_ser.end()
5855 }
5856}
5857impl<'de> serde::Deserialize<'de> for InequalityPair {
5858 #[allow(deprecated)]
5859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5860 where
5861 D: serde::Deserializer<'de>,
5862 {
5863 const FIELDS: &[&str] = &[
5864 "key_required_larger",
5865 "keyRequiredLarger",
5866 "key_required_smaller",
5867 "keyRequiredSmaller",
5868 "clean_state",
5869 "cleanState",
5870 "delta_expression",
5871 "deltaExpression",
5872 ];
5873
5874 #[allow(clippy::enum_variant_names)]
5875 enum GeneratedField {
5876 KeyRequiredLarger,
5877 KeyRequiredSmaller,
5878 CleanState,
5879 DeltaExpression,
5880 }
5881 impl<'de> serde::Deserialize<'de> for GeneratedField {
5882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5883 where
5884 D: serde::Deserializer<'de>,
5885 {
5886 struct GeneratedVisitor;
5887
5888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5889 type Value = GeneratedField;
5890
5891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5892 write!(formatter, "expected one of: {:?}", &FIELDS)
5893 }
5894
5895 #[allow(unused_variables)]
5896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5897 where
5898 E: serde::de::Error,
5899 {
5900 match value {
5901 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
5902 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
5903 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
5904 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
5905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5906 }
5907 }
5908 }
5909 deserializer.deserialize_identifier(GeneratedVisitor)
5910 }
5911 }
5912 struct GeneratedVisitor;
5913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5914 type Value = InequalityPair;
5915
5916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5917 formatter.write_str("struct stream_plan.InequalityPair")
5918 }
5919
5920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
5921 where
5922 V: serde::de::MapAccess<'de>,
5923 {
5924 let mut key_required_larger__ = None;
5925 let mut key_required_smaller__ = None;
5926 let mut clean_state__ = None;
5927 let mut delta_expression__ = None;
5928 while let Some(k) = map_.next_key()? {
5929 match k {
5930 GeneratedField::KeyRequiredLarger => {
5931 if key_required_larger__.is_some() {
5932 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
5933 }
5934 key_required_larger__ =
5935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5936 ;
5937 }
5938 GeneratedField::KeyRequiredSmaller => {
5939 if key_required_smaller__.is_some() {
5940 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
5941 }
5942 key_required_smaller__ =
5943 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5944 ;
5945 }
5946 GeneratedField::CleanState => {
5947 if clean_state__.is_some() {
5948 return Err(serde::de::Error::duplicate_field("cleanState"));
5949 }
5950 clean_state__ = Some(map_.next_value()?);
5951 }
5952 GeneratedField::DeltaExpression => {
5953 if delta_expression__.is_some() {
5954 return Err(serde::de::Error::duplicate_field("deltaExpression"));
5955 }
5956 delta_expression__ = map_.next_value()?;
5957 }
5958 }
5959 }
5960 Ok(InequalityPair {
5961 key_required_larger: key_required_larger__.unwrap_or_default(),
5962 key_required_smaller: key_required_smaller__.unwrap_or_default(),
5963 clean_state: clean_state__.unwrap_or_default(),
5964 delta_expression: delta_expression__,
5965 })
5966 }
5967 }
5968 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
5969 }
5970}
5971impl serde::Serialize for JoinEncodingType {
5972 #[allow(deprecated)]
5973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5974 where
5975 S: serde::Serializer,
5976 {
5977 let variant = match self {
5978 Self::Unspecified => "UNSPECIFIED",
5979 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
5980 Self::CpuOptimized => "CPU_OPTIMIZED",
5981 };
5982 serializer.serialize_str(variant)
5983 }
5984}
5985impl<'de> serde::Deserialize<'de> for JoinEncodingType {
5986 #[allow(deprecated)]
5987 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5988 where
5989 D: serde::Deserializer<'de>,
5990 {
5991 const FIELDS: &[&str] = &[
5992 "UNSPECIFIED",
5993 "MEMORY_OPTIMIZED",
5994 "CPU_OPTIMIZED",
5995 ];
5996
5997 struct GeneratedVisitor;
5998
5999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6000 type Value = JoinEncodingType;
6001
6002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6003 write!(formatter, "expected one of: {:?}", &FIELDS)
6004 }
6005
6006 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6007 where
6008 E: serde::de::Error,
6009 {
6010 i32::try_from(v)
6011 .ok()
6012 .and_then(|x| x.try_into().ok())
6013 .ok_or_else(|| {
6014 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6015 })
6016 }
6017
6018 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6019 where
6020 E: serde::de::Error,
6021 {
6022 i32::try_from(v)
6023 .ok()
6024 .and_then(|x| x.try_into().ok())
6025 .ok_or_else(|| {
6026 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6027 })
6028 }
6029
6030 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6031 where
6032 E: serde::de::Error,
6033 {
6034 match value {
6035 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6036 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6037 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6038 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6039 }
6040 }
6041 }
6042 deserializer.deserialize_any(GeneratedVisitor)
6043 }
6044}
6045impl serde::Serialize for LoadFinishMutation {
6046 #[allow(deprecated)]
6047 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6048 where
6049 S: serde::Serializer,
6050 {
6051 use serde::ser::SerializeStruct;
6052 let mut len = 0;
6053 if self.associated_source_id != 0 {
6054 len += 1;
6055 }
6056 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
6057 if self.associated_source_id != 0 {
6058 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6059 }
6060 struct_ser.end()
6061 }
6062}
6063impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
6064 #[allow(deprecated)]
6065 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6066 where
6067 D: serde::Deserializer<'de>,
6068 {
6069 const FIELDS: &[&str] = &[
6070 "associated_source_id",
6071 "associatedSourceId",
6072 ];
6073
6074 #[allow(clippy::enum_variant_names)]
6075 enum GeneratedField {
6076 AssociatedSourceId,
6077 }
6078 impl<'de> serde::Deserialize<'de> for GeneratedField {
6079 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6080 where
6081 D: serde::Deserializer<'de>,
6082 {
6083 struct GeneratedVisitor;
6084
6085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6086 type Value = GeneratedField;
6087
6088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6089 write!(formatter, "expected one of: {:?}", &FIELDS)
6090 }
6091
6092 #[allow(unused_variables)]
6093 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6094 where
6095 E: serde::de::Error,
6096 {
6097 match value {
6098 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6099 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6100 }
6101 }
6102 }
6103 deserializer.deserialize_identifier(GeneratedVisitor)
6104 }
6105 }
6106 struct GeneratedVisitor;
6107 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6108 type Value = LoadFinishMutation;
6109
6110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6111 formatter.write_str("struct stream_plan.LoadFinishMutation")
6112 }
6113
6114 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
6115 where
6116 V: serde::de::MapAccess<'de>,
6117 {
6118 let mut associated_source_id__ = None;
6119 while let Some(k) = map_.next_key()? {
6120 match k {
6121 GeneratedField::AssociatedSourceId => {
6122 if associated_source_id__.is_some() {
6123 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6124 }
6125 associated_source_id__ =
6126 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6127 ;
6128 }
6129 }
6130 }
6131 Ok(LoadFinishMutation {
6132 associated_source_id: associated_source_id__.unwrap_or_default(),
6133 })
6134 }
6135 }
6136 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
6137 }
6138}
6139impl serde::Serialize for LocalApproxPercentileNode {
6140 #[allow(deprecated)]
6141 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6142 where
6143 S: serde::Serializer,
6144 {
6145 use serde::ser::SerializeStruct;
6146 let mut len = 0;
6147 if self.base != 0. {
6148 len += 1;
6149 }
6150 if self.percentile_index != 0 {
6151 len += 1;
6152 }
6153 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6154 if self.base != 0. {
6155 struct_ser.serialize_field("base", &self.base)?;
6156 }
6157 if self.percentile_index != 0 {
6158 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6159 }
6160 struct_ser.end()
6161 }
6162}
6163impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6164 #[allow(deprecated)]
6165 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6166 where
6167 D: serde::Deserializer<'de>,
6168 {
6169 const FIELDS: &[&str] = &[
6170 "base",
6171 "percentile_index",
6172 "percentileIndex",
6173 ];
6174
6175 #[allow(clippy::enum_variant_names)]
6176 enum GeneratedField {
6177 Base,
6178 PercentileIndex,
6179 }
6180 impl<'de> serde::Deserialize<'de> for GeneratedField {
6181 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6182 where
6183 D: serde::Deserializer<'de>,
6184 {
6185 struct GeneratedVisitor;
6186
6187 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6188 type Value = GeneratedField;
6189
6190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6191 write!(formatter, "expected one of: {:?}", &FIELDS)
6192 }
6193
6194 #[allow(unused_variables)]
6195 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6196 where
6197 E: serde::de::Error,
6198 {
6199 match value {
6200 "base" => Ok(GeneratedField::Base),
6201 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6202 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6203 }
6204 }
6205 }
6206 deserializer.deserialize_identifier(GeneratedVisitor)
6207 }
6208 }
6209 struct GeneratedVisitor;
6210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6211 type Value = LocalApproxPercentileNode;
6212
6213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6214 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6215 }
6216
6217 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6218 where
6219 V: serde::de::MapAccess<'de>,
6220 {
6221 let mut base__ = None;
6222 let mut percentile_index__ = None;
6223 while let Some(k) = map_.next_key()? {
6224 match k {
6225 GeneratedField::Base => {
6226 if base__.is_some() {
6227 return Err(serde::de::Error::duplicate_field("base"));
6228 }
6229 base__ =
6230 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6231 ;
6232 }
6233 GeneratedField::PercentileIndex => {
6234 if percentile_index__.is_some() {
6235 return Err(serde::de::Error::duplicate_field("percentileIndex"));
6236 }
6237 percentile_index__ =
6238 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6239 ;
6240 }
6241 }
6242 }
6243 Ok(LocalApproxPercentileNode {
6244 base: base__.unwrap_or_default(),
6245 percentile_index: percentile_index__.unwrap_or_default(),
6246 })
6247 }
6248 }
6249 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6250 }
6251}
6252impl serde::Serialize for LookupNode {
6253 #[allow(deprecated)]
6254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6255 where
6256 S: serde::Serializer,
6257 {
6258 use serde::ser::SerializeStruct;
6259 let mut len = 0;
6260 if !self.arrange_key.is_empty() {
6261 len += 1;
6262 }
6263 if !self.stream_key.is_empty() {
6264 len += 1;
6265 }
6266 if self.use_current_epoch {
6267 len += 1;
6268 }
6269 if !self.column_mapping.is_empty() {
6270 len += 1;
6271 }
6272 if self.arrangement_table_info.is_some() {
6273 len += 1;
6274 }
6275 if self.arrangement_table_id.is_some() {
6276 len += 1;
6277 }
6278 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6279 if !self.arrange_key.is_empty() {
6280 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6281 }
6282 if !self.stream_key.is_empty() {
6283 struct_ser.serialize_field("streamKey", &self.stream_key)?;
6284 }
6285 if self.use_current_epoch {
6286 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6287 }
6288 if !self.column_mapping.is_empty() {
6289 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6290 }
6291 if let Some(v) = self.arrangement_table_info.as_ref() {
6292 struct_ser.serialize_field("arrangementTableInfo", v)?;
6293 }
6294 if let Some(v) = self.arrangement_table_id.as_ref() {
6295 match v {
6296 lookup_node::ArrangementTableId::TableId(v) => {
6297 struct_ser.serialize_field("tableId", v)?;
6298 }
6299 lookup_node::ArrangementTableId::IndexId(v) => {
6300 struct_ser.serialize_field("indexId", v)?;
6301 }
6302 }
6303 }
6304 struct_ser.end()
6305 }
6306}
6307impl<'de> serde::Deserialize<'de> for LookupNode {
6308 #[allow(deprecated)]
6309 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6310 where
6311 D: serde::Deserializer<'de>,
6312 {
6313 const FIELDS: &[&str] = &[
6314 "arrange_key",
6315 "arrangeKey",
6316 "stream_key",
6317 "streamKey",
6318 "use_current_epoch",
6319 "useCurrentEpoch",
6320 "column_mapping",
6321 "columnMapping",
6322 "arrangement_table_info",
6323 "arrangementTableInfo",
6324 "table_id",
6325 "tableId",
6326 "index_id",
6327 "indexId",
6328 ];
6329
6330 #[allow(clippy::enum_variant_names)]
6331 enum GeneratedField {
6332 ArrangeKey,
6333 StreamKey,
6334 UseCurrentEpoch,
6335 ColumnMapping,
6336 ArrangementTableInfo,
6337 TableId,
6338 IndexId,
6339 }
6340 impl<'de> serde::Deserialize<'de> for GeneratedField {
6341 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6342 where
6343 D: serde::Deserializer<'de>,
6344 {
6345 struct GeneratedVisitor;
6346
6347 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6348 type Value = GeneratedField;
6349
6350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6351 write!(formatter, "expected one of: {:?}", &FIELDS)
6352 }
6353
6354 #[allow(unused_variables)]
6355 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6356 where
6357 E: serde::de::Error,
6358 {
6359 match value {
6360 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6361 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6362 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6363 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6364 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6365 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6366 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6367 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6368 }
6369 }
6370 }
6371 deserializer.deserialize_identifier(GeneratedVisitor)
6372 }
6373 }
6374 struct GeneratedVisitor;
6375 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6376 type Value = LookupNode;
6377
6378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6379 formatter.write_str("struct stream_plan.LookupNode")
6380 }
6381
6382 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6383 where
6384 V: serde::de::MapAccess<'de>,
6385 {
6386 let mut arrange_key__ = None;
6387 let mut stream_key__ = None;
6388 let mut use_current_epoch__ = None;
6389 let mut column_mapping__ = None;
6390 let mut arrangement_table_info__ = None;
6391 let mut arrangement_table_id__ = None;
6392 while let Some(k) = map_.next_key()? {
6393 match k {
6394 GeneratedField::ArrangeKey => {
6395 if arrange_key__.is_some() {
6396 return Err(serde::de::Error::duplicate_field("arrangeKey"));
6397 }
6398 arrange_key__ =
6399 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6400 .into_iter().map(|x| x.0).collect())
6401 ;
6402 }
6403 GeneratedField::StreamKey => {
6404 if stream_key__.is_some() {
6405 return Err(serde::de::Error::duplicate_field("streamKey"));
6406 }
6407 stream_key__ =
6408 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6409 .into_iter().map(|x| x.0).collect())
6410 ;
6411 }
6412 GeneratedField::UseCurrentEpoch => {
6413 if use_current_epoch__.is_some() {
6414 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6415 }
6416 use_current_epoch__ = Some(map_.next_value()?);
6417 }
6418 GeneratedField::ColumnMapping => {
6419 if column_mapping__.is_some() {
6420 return Err(serde::de::Error::duplicate_field("columnMapping"));
6421 }
6422 column_mapping__ =
6423 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6424 .into_iter().map(|x| x.0).collect())
6425 ;
6426 }
6427 GeneratedField::ArrangementTableInfo => {
6428 if arrangement_table_info__.is_some() {
6429 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6430 }
6431 arrangement_table_info__ = map_.next_value()?;
6432 }
6433 GeneratedField::TableId => {
6434 if arrangement_table_id__.is_some() {
6435 return Err(serde::de::Error::duplicate_field("tableId"));
6436 }
6437 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6438 }
6439 GeneratedField::IndexId => {
6440 if arrangement_table_id__.is_some() {
6441 return Err(serde::de::Error::duplicate_field("indexId"));
6442 }
6443 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6444 }
6445 }
6446 }
6447 Ok(LookupNode {
6448 arrange_key: arrange_key__.unwrap_or_default(),
6449 stream_key: stream_key__.unwrap_or_default(),
6450 use_current_epoch: use_current_epoch__.unwrap_or_default(),
6451 column_mapping: column_mapping__.unwrap_or_default(),
6452 arrangement_table_info: arrangement_table_info__,
6453 arrangement_table_id: arrangement_table_id__,
6454 })
6455 }
6456 }
6457 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6458 }
6459}
6460impl serde::Serialize for LookupUnionNode {
6461 #[allow(deprecated)]
6462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6463 where
6464 S: serde::Serializer,
6465 {
6466 use serde::ser::SerializeStruct;
6467 let mut len = 0;
6468 if !self.order.is_empty() {
6469 len += 1;
6470 }
6471 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6472 if !self.order.is_empty() {
6473 struct_ser.serialize_field("order", &self.order)?;
6474 }
6475 struct_ser.end()
6476 }
6477}
6478impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6479 #[allow(deprecated)]
6480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6481 where
6482 D: serde::Deserializer<'de>,
6483 {
6484 const FIELDS: &[&str] = &[
6485 "order",
6486 ];
6487
6488 #[allow(clippy::enum_variant_names)]
6489 enum GeneratedField {
6490 Order,
6491 }
6492 impl<'de> serde::Deserialize<'de> for GeneratedField {
6493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6494 where
6495 D: serde::Deserializer<'de>,
6496 {
6497 struct GeneratedVisitor;
6498
6499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6500 type Value = GeneratedField;
6501
6502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6503 write!(formatter, "expected one of: {:?}", &FIELDS)
6504 }
6505
6506 #[allow(unused_variables)]
6507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6508 where
6509 E: serde::de::Error,
6510 {
6511 match value {
6512 "order" => Ok(GeneratedField::Order),
6513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6514 }
6515 }
6516 }
6517 deserializer.deserialize_identifier(GeneratedVisitor)
6518 }
6519 }
6520 struct GeneratedVisitor;
6521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6522 type Value = LookupUnionNode;
6523
6524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6525 formatter.write_str("struct stream_plan.LookupUnionNode")
6526 }
6527
6528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6529 where
6530 V: serde::de::MapAccess<'de>,
6531 {
6532 let mut order__ = None;
6533 while let Some(k) = map_.next_key()? {
6534 match k {
6535 GeneratedField::Order => {
6536 if order__.is_some() {
6537 return Err(serde::de::Error::duplicate_field("order"));
6538 }
6539 order__ =
6540 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6541 .into_iter().map(|x| x.0).collect())
6542 ;
6543 }
6544 }
6545 }
6546 Ok(LookupUnionNode {
6547 order: order__.unwrap_or_default(),
6548 })
6549 }
6550 }
6551 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6552 }
6553}
6554impl serde::Serialize for MaterializeNode {
6555 #[allow(deprecated)]
6556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6557 where
6558 S: serde::Serializer,
6559 {
6560 use serde::ser::SerializeStruct;
6561 let mut len = 0;
6562 if self.table_id != 0 {
6563 len += 1;
6564 }
6565 if !self.column_orders.is_empty() {
6566 len += 1;
6567 }
6568 if self.table.is_some() {
6569 len += 1;
6570 }
6571 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6572 if self.table_id != 0 {
6573 struct_ser.serialize_field("tableId", &self.table_id)?;
6574 }
6575 if !self.column_orders.is_empty() {
6576 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6577 }
6578 if let Some(v) = self.table.as_ref() {
6579 struct_ser.serialize_field("table", v)?;
6580 }
6581 struct_ser.end()
6582 }
6583}
6584impl<'de> serde::Deserialize<'de> for MaterializeNode {
6585 #[allow(deprecated)]
6586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6587 where
6588 D: serde::Deserializer<'de>,
6589 {
6590 const FIELDS: &[&str] = &[
6591 "table_id",
6592 "tableId",
6593 "column_orders",
6594 "columnOrders",
6595 "table",
6596 ];
6597
6598 #[allow(clippy::enum_variant_names)]
6599 enum GeneratedField {
6600 TableId,
6601 ColumnOrders,
6602 Table,
6603 }
6604 impl<'de> serde::Deserialize<'de> for GeneratedField {
6605 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6606 where
6607 D: serde::Deserializer<'de>,
6608 {
6609 struct GeneratedVisitor;
6610
6611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6612 type Value = GeneratedField;
6613
6614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6615 write!(formatter, "expected one of: {:?}", &FIELDS)
6616 }
6617
6618 #[allow(unused_variables)]
6619 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6620 where
6621 E: serde::de::Error,
6622 {
6623 match value {
6624 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6625 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6626 "table" => Ok(GeneratedField::Table),
6627 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6628 }
6629 }
6630 }
6631 deserializer.deserialize_identifier(GeneratedVisitor)
6632 }
6633 }
6634 struct GeneratedVisitor;
6635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6636 type Value = MaterializeNode;
6637
6638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6639 formatter.write_str("struct stream_plan.MaterializeNode")
6640 }
6641
6642 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6643 where
6644 V: serde::de::MapAccess<'de>,
6645 {
6646 let mut table_id__ = None;
6647 let mut column_orders__ = None;
6648 let mut table__ = None;
6649 while let Some(k) = map_.next_key()? {
6650 match k {
6651 GeneratedField::TableId => {
6652 if table_id__.is_some() {
6653 return Err(serde::de::Error::duplicate_field("tableId"));
6654 }
6655 table_id__ =
6656 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6657 ;
6658 }
6659 GeneratedField::ColumnOrders => {
6660 if column_orders__.is_some() {
6661 return Err(serde::de::Error::duplicate_field("columnOrders"));
6662 }
6663 column_orders__ = Some(map_.next_value()?);
6664 }
6665 GeneratedField::Table => {
6666 if table__.is_some() {
6667 return Err(serde::de::Error::duplicate_field("table"));
6668 }
6669 table__ = map_.next_value()?;
6670 }
6671 }
6672 }
6673 Ok(MaterializeNode {
6674 table_id: table_id__.unwrap_or_default(),
6675 column_orders: column_orders__.unwrap_or_default(),
6676 table: table__,
6677 })
6678 }
6679 }
6680 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6681 }
6682}
6683impl serde::Serialize for MaterializedExprsNode {
6684 #[allow(deprecated)]
6685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6686 where
6687 S: serde::Serializer,
6688 {
6689 use serde::ser::SerializeStruct;
6690 let mut len = 0;
6691 if !self.exprs.is_empty() {
6692 len += 1;
6693 }
6694 if self.state_table.is_some() {
6695 len += 1;
6696 }
6697 if self.state_clean_col_idx.is_some() {
6698 len += 1;
6699 }
6700 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6701 if !self.exprs.is_empty() {
6702 struct_ser.serialize_field("exprs", &self.exprs)?;
6703 }
6704 if let Some(v) = self.state_table.as_ref() {
6705 struct_ser.serialize_field("stateTable", v)?;
6706 }
6707 if let Some(v) = self.state_clean_col_idx.as_ref() {
6708 struct_ser.serialize_field("stateCleanColIdx", v)?;
6709 }
6710 struct_ser.end()
6711 }
6712}
6713impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6714 #[allow(deprecated)]
6715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6716 where
6717 D: serde::Deserializer<'de>,
6718 {
6719 const FIELDS: &[&str] = &[
6720 "exprs",
6721 "state_table",
6722 "stateTable",
6723 "state_clean_col_idx",
6724 "stateCleanColIdx",
6725 ];
6726
6727 #[allow(clippy::enum_variant_names)]
6728 enum GeneratedField {
6729 Exprs,
6730 StateTable,
6731 StateCleanColIdx,
6732 }
6733 impl<'de> serde::Deserialize<'de> for GeneratedField {
6734 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6735 where
6736 D: serde::Deserializer<'de>,
6737 {
6738 struct GeneratedVisitor;
6739
6740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6741 type Value = GeneratedField;
6742
6743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6744 write!(formatter, "expected one of: {:?}", &FIELDS)
6745 }
6746
6747 #[allow(unused_variables)]
6748 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6749 where
6750 E: serde::de::Error,
6751 {
6752 match value {
6753 "exprs" => Ok(GeneratedField::Exprs),
6754 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6755 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
6756 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6757 }
6758 }
6759 }
6760 deserializer.deserialize_identifier(GeneratedVisitor)
6761 }
6762 }
6763 struct GeneratedVisitor;
6764 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6765 type Value = MaterializedExprsNode;
6766
6767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6768 formatter.write_str("struct stream_plan.MaterializedExprsNode")
6769 }
6770
6771 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6772 where
6773 V: serde::de::MapAccess<'de>,
6774 {
6775 let mut exprs__ = None;
6776 let mut state_table__ = None;
6777 let mut state_clean_col_idx__ = None;
6778 while let Some(k) = map_.next_key()? {
6779 match k {
6780 GeneratedField::Exprs => {
6781 if exprs__.is_some() {
6782 return Err(serde::de::Error::duplicate_field("exprs"));
6783 }
6784 exprs__ = Some(map_.next_value()?);
6785 }
6786 GeneratedField::StateTable => {
6787 if state_table__.is_some() {
6788 return Err(serde::de::Error::duplicate_field("stateTable"));
6789 }
6790 state_table__ = map_.next_value()?;
6791 }
6792 GeneratedField::StateCleanColIdx => {
6793 if state_clean_col_idx__.is_some() {
6794 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6795 }
6796 state_clean_col_idx__ =
6797 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6798 ;
6799 }
6800 }
6801 }
6802 Ok(MaterializedExprsNode {
6803 exprs: exprs__.unwrap_or_default(),
6804 state_table: state_table__,
6805 state_clean_col_idx: state_clean_col_idx__,
6806 })
6807 }
6808 }
6809 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6810 }
6811}
6812impl serde::Serialize for MergeNode {
6813 #[allow(deprecated)]
6814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6815 where
6816 S: serde::Serializer,
6817 {
6818 use serde::ser::SerializeStruct;
6819 let mut len = 0;
6820 if !self.upstream_actor_id.is_empty() {
6821 len += 1;
6822 }
6823 if self.upstream_fragment_id != 0 {
6824 len += 1;
6825 }
6826 if self.upstream_dispatcher_type != 0 {
6827 len += 1;
6828 }
6829 if !self.fields.is_empty() {
6830 len += 1;
6831 }
6832 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
6833 if !self.upstream_actor_id.is_empty() {
6834 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
6835 }
6836 if self.upstream_fragment_id != 0 {
6837 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
6838 }
6839 if self.upstream_dispatcher_type != 0 {
6840 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
6841 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
6842 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
6843 }
6844 if !self.fields.is_empty() {
6845 struct_ser.serialize_field("fields", &self.fields)?;
6846 }
6847 struct_ser.end()
6848 }
6849}
6850impl<'de> serde::Deserialize<'de> for MergeNode {
6851 #[allow(deprecated)]
6852 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6853 where
6854 D: serde::Deserializer<'de>,
6855 {
6856 const FIELDS: &[&str] = &[
6857 "upstream_actor_id",
6858 "upstreamActorId",
6859 "upstream_fragment_id",
6860 "upstreamFragmentId",
6861 "upstream_dispatcher_type",
6862 "upstreamDispatcherType",
6863 "fields",
6864 ];
6865
6866 #[allow(clippy::enum_variant_names)]
6867 enum GeneratedField {
6868 UpstreamActorId,
6869 UpstreamFragmentId,
6870 UpstreamDispatcherType,
6871 Fields,
6872 }
6873 impl<'de> serde::Deserialize<'de> for GeneratedField {
6874 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6875 where
6876 D: serde::Deserializer<'de>,
6877 {
6878 struct GeneratedVisitor;
6879
6880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6881 type Value = GeneratedField;
6882
6883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6884 write!(formatter, "expected one of: {:?}", &FIELDS)
6885 }
6886
6887 #[allow(unused_variables)]
6888 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6889 where
6890 E: serde::de::Error,
6891 {
6892 match value {
6893 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
6894 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
6895 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
6896 "fields" => Ok(GeneratedField::Fields),
6897 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6898 }
6899 }
6900 }
6901 deserializer.deserialize_identifier(GeneratedVisitor)
6902 }
6903 }
6904 struct GeneratedVisitor;
6905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6906 type Value = MergeNode;
6907
6908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6909 formatter.write_str("struct stream_plan.MergeNode")
6910 }
6911
6912 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
6913 where
6914 V: serde::de::MapAccess<'de>,
6915 {
6916 let mut upstream_actor_id__ = None;
6917 let mut upstream_fragment_id__ = None;
6918 let mut upstream_dispatcher_type__ = None;
6919 let mut fields__ = None;
6920 while let Some(k) = map_.next_key()? {
6921 match k {
6922 GeneratedField::UpstreamActorId => {
6923 if upstream_actor_id__.is_some() {
6924 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
6925 }
6926 upstream_actor_id__ =
6927 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6928 .into_iter().map(|x| x.0).collect())
6929 ;
6930 }
6931 GeneratedField::UpstreamFragmentId => {
6932 if upstream_fragment_id__.is_some() {
6933 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
6934 }
6935 upstream_fragment_id__ =
6936 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6937 ;
6938 }
6939 GeneratedField::UpstreamDispatcherType => {
6940 if upstream_dispatcher_type__.is_some() {
6941 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
6942 }
6943 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
6944 }
6945 GeneratedField::Fields => {
6946 if fields__.is_some() {
6947 return Err(serde::de::Error::duplicate_field("fields"));
6948 }
6949 fields__ = Some(map_.next_value()?);
6950 }
6951 }
6952 }
6953 Ok(MergeNode {
6954 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
6955 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
6956 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
6957 fields: fields__.unwrap_or_default(),
6958 })
6959 }
6960 }
6961 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
6962 }
6963}
6964impl serde::Serialize for NoOpNode {
6965 #[allow(deprecated)]
6966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6967 where
6968 S: serde::Serializer,
6969 {
6970 use serde::ser::SerializeStruct;
6971 let len = 0;
6972 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
6973 struct_ser.end()
6974 }
6975}
6976impl<'de> serde::Deserialize<'de> for NoOpNode {
6977 #[allow(deprecated)]
6978 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6979 where
6980 D: serde::Deserializer<'de>,
6981 {
6982 const FIELDS: &[&str] = &[
6983 ];
6984
6985 #[allow(clippy::enum_variant_names)]
6986 enum GeneratedField {
6987 }
6988 impl<'de> serde::Deserialize<'de> for GeneratedField {
6989 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6990 where
6991 D: serde::Deserializer<'de>,
6992 {
6993 struct GeneratedVisitor;
6994
6995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6996 type Value = GeneratedField;
6997
6998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6999 write!(formatter, "expected one of: {:?}", &FIELDS)
7000 }
7001
7002 #[allow(unused_variables)]
7003 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7004 where
7005 E: serde::de::Error,
7006 {
7007 Err(serde::de::Error::unknown_field(value, FIELDS))
7008 }
7009 }
7010 deserializer.deserialize_identifier(GeneratedVisitor)
7011 }
7012 }
7013 struct GeneratedVisitor;
7014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7015 type Value = NoOpNode;
7016
7017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7018 formatter.write_str("struct stream_plan.NoOpNode")
7019 }
7020
7021 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7022 where
7023 V: serde::de::MapAccess<'de>,
7024 {
7025 while map_.next_key::<GeneratedField>()?.is_some() {
7026 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7027 }
7028 Ok(NoOpNode {
7029 })
7030 }
7031 }
7032 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7033 }
7034}
7035impl serde::Serialize for NowModeGenerateSeries {
7036 #[allow(deprecated)]
7037 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7038 where
7039 S: serde::Serializer,
7040 {
7041 use serde::ser::SerializeStruct;
7042 let mut len = 0;
7043 if self.start_timestamp.is_some() {
7044 len += 1;
7045 }
7046 if self.interval.is_some() {
7047 len += 1;
7048 }
7049 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7050 if let Some(v) = self.start_timestamp.as_ref() {
7051 struct_ser.serialize_field("startTimestamp", v)?;
7052 }
7053 if let Some(v) = self.interval.as_ref() {
7054 struct_ser.serialize_field("interval", v)?;
7055 }
7056 struct_ser.end()
7057 }
7058}
7059impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
7060 #[allow(deprecated)]
7061 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7062 where
7063 D: serde::Deserializer<'de>,
7064 {
7065 const FIELDS: &[&str] = &[
7066 "start_timestamp",
7067 "startTimestamp",
7068 "interval",
7069 ];
7070
7071 #[allow(clippy::enum_variant_names)]
7072 enum GeneratedField {
7073 StartTimestamp,
7074 Interval,
7075 }
7076 impl<'de> serde::Deserialize<'de> for GeneratedField {
7077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7078 where
7079 D: serde::Deserializer<'de>,
7080 {
7081 struct GeneratedVisitor;
7082
7083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7084 type Value = GeneratedField;
7085
7086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7087 write!(formatter, "expected one of: {:?}", &FIELDS)
7088 }
7089
7090 #[allow(unused_variables)]
7091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7092 where
7093 E: serde::de::Error,
7094 {
7095 match value {
7096 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7097 "interval" => Ok(GeneratedField::Interval),
7098 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7099 }
7100 }
7101 }
7102 deserializer.deserialize_identifier(GeneratedVisitor)
7103 }
7104 }
7105 struct GeneratedVisitor;
7106 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7107 type Value = NowModeGenerateSeries;
7108
7109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7110 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7111 }
7112
7113 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7114 where
7115 V: serde::de::MapAccess<'de>,
7116 {
7117 let mut start_timestamp__ = None;
7118 let mut interval__ = None;
7119 while let Some(k) = map_.next_key()? {
7120 match k {
7121 GeneratedField::StartTimestamp => {
7122 if start_timestamp__.is_some() {
7123 return Err(serde::de::Error::duplicate_field("startTimestamp"));
7124 }
7125 start_timestamp__ = map_.next_value()?;
7126 }
7127 GeneratedField::Interval => {
7128 if interval__.is_some() {
7129 return Err(serde::de::Error::duplicate_field("interval"));
7130 }
7131 interval__ = map_.next_value()?;
7132 }
7133 }
7134 }
7135 Ok(NowModeGenerateSeries {
7136 start_timestamp: start_timestamp__,
7137 interval: interval__,
7138 })
7139 }
7140 }
7141 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
7142 }
7143}
7144impl serde::Serialize for NowModeUpdateCurrent {
7145 #[allow(deprecated)]
7146 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7147 where
7148 S: serde::Serializer,
7149 {
7150 use serde::ser::SerializeStruct;
7151 let len = 0;
7152 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7153 struct_ser.end()
7154 }
7155}
7156impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7157 #[allow(deprecated)]
7158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7159 where
7160 D: serde::Deserializer<'de>,
7161 {
7162 const FIELDS: &[&str] = &[
7163 ];
7164
7165 #[allow(clippy::enum_variant_names)]
7166 enum GeneratedField {
7167 }
7168 impl<'de> serde::Deserialize<'de> for GeneratedField {
7169 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7170 where
7171 D: serde::Deserializer<'de>,
7172 {
7173 struct GeneratedVisitor;
7174
7175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7176 type Value = GeneratedField;
7177
7178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7179 write!(formatter, "expected one of: {:?}", &FIELDS)
7180 }
7181
7182 #[allow(unused_variables)]
7183 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7184 where
7185 E: serde::de::Error,
7186 {
7187 Err(serde::de::Error::unknown_field(value, FIELDS))
7188 }
7189 }
7190 deserializer.deserialize_identifier(GeneratedVisitor)
7191 }
7192 }
7193 struct GeneratedVisitor;
7194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7195 type Value = NowModeUpdateCurrent;
7196
7197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7198 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7199 }
7200
7201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7202 where
7203 V: serde::de::MapAccess<'de>,
7204 {
7205 while map_.next_key::<GeneratedField>()?.is_some() {
7206 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7207 }
7208 Ok(NowModeUpdateCurrent {
7209 })
7210 }
7211 }
7212 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7213 }
7214}
7215impl serde::Serialize for NowNode {
7216 #[allow(deprecated)]
7217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7218 where
7219 S: serde::Serializer,
7220 {
7221 use serde::ser::SerializeStruct;
7222 let mut len = 0;
7223 if self.state_table.is_some() {
7224 len += 1;
7225 }
7226 if self.mode.is_some() {
7227 len += 1;
7228 }
7229 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7230 if let Some(v) = self.state_table.as_ref() {
7231 struct_ser.serialize_field("stateTable", v)?;
7232 }
7233 if let Some(v) = self.mode.as_ref() {
7234 match v {
7235 now_node::Mode::UpdateCurrent(v) => {
7236 struct_ser.serialize_field("updateCurrent", v)?;
7237 }
7238 now_node::Mode::GenerateSeries(v) => {
7239 struct_ser.serialize_field("generateSeries", v)?;
7240 }
7241 }
7242 }
7243 struct_ser.end()
7244 }
7245}
7246impl<'de> serde::Deserialize<'de> for NowNode {
7247 #[allow(deprecated)]
7248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7249 where
7250 D: serde::Deserializer<'de>,
7251 {
7252 const FIELDS: &[&str] = &[
7253 "state_table",
7254 "stateTable",
7255 "update_current",
7256 "updateCurrent",
7257 "generate_series",
7258 "generateSeries",
7259 ];
7260
7261 #[allow(clippy::enum_variant_names)]
7262 enum GeneratedField {
7263 StateTable,
7264 UpdateCurrent,
7265 GenerateSeries,
7266 }
7267 impl<'de> serde::Deserialize<'de> for GeneratedField {
7268 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7269 where
7270 D: serde::Deserializer<'de>,
7271 {
7272 struct GeneratedVisitor;
7273
7274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7275 type Value = GeneratedField;
7276
7277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7278 write!(formatter, "expected one of: {:?}", &FIELDS)
7279 }
7280
7281 #[allow(unused_variables)]
7282 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7283 where
7284 E: serde::de::Error,
7285 {
7286 match value {
7287 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7288 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7289 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7290 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7291 }
7292 }
7293 }
7294 deserializer.deserialize_identifier(GeneratedVisitor)
7295 }
7296 }
7297 struct GeneratedVisitor;
7298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7299 type Value = NowNode;
7300
7301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7302 formatter.write_str("struct stream_plan.NowNode")
7303 }
7304
7305 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7306 where
7307 V: serde::de::MapAccess<'de>,
7308 {
7309 let mut state_table__ = None;
7310 let mut mode__ = None;
7311 while let Some(k) = map_.next_key()? {
7312 match k {
7313 GeneratedField::StateTable => {
7314 if state_table__.is_some() {
7315 return Err(serde::de::Error::duplicate_field("stateTable"));
7316 }
7317 state_table__ = map_.next_value()?;
7318 }
7319 GeneratedField::UpdateCurrent => {
7320 if mode__.is_some() {
7321 return Err(serde::de::Error::duplicate_field("updateCurrent"));
7322 }
7323 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7324;
7325 }
7326 GeneratedField::GenerateSeries => {
7327 if mode__.is_some() {
7328 return Err(serde::de::Error::duplicate_field("generateSeries"));
7329 }
7330 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7331;
7332 }
7333 }
7334 }
7335 Ok(NowNode {
7336 state_table: state_table__,
7337 mode: mode__,
7338 })
7339 }
7340 }
7341 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7342 }
7343}
7344impl serde::Serialize for OverWindowCachePolicy {
7345 #[allow(deprecated)]
7346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7347 where
7348 S: serde::Serializer,
7349 {
7350 let variant = match self {
7351 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7352 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7353 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7354 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7355 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7356 };
7357 serializer.serialize_str(variant)
7358 }
7359}
7360impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7361 #[allow(deprecated)]
7362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7363 where
7364 D: serde::Deserializer<'de>,
7365 {
7366 const FIELDS: &[&str] = &[
7367 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7368 "OVER_WINDOW_CACHE_POLICY_FULL",
7369 "OVER_WINDOW_CACHE_POLICY_RECENT",
7370 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7371 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7372 ];
7373
7374 struct GeneratedVisitor;
7375
7376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7377 type Value = OverWindowCachePolicy;
7378
7379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7380 write!(formatter, "expected one of: {:?}", &FIELDS)
7381 }
7382
7383 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7384 where
7385 E: serde::de::Error,
7386 {
7387 i32::try_from(v)
7388 .ok()
7389 .and_then(|x| x.try_into().ok())
7390 .ok_or_else(|| {
7391 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7392 })
7393 }
7394
7395 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7396 where
7397 E: serde::de::Error,
7398 {
7399 i32::try_from(v)
7400 .ok()
7401 .and_then(|x| x.try_into().ok())
7402 .ok_or_else(|| {
7403 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7404 })
7405 }
7406
7407 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7408 where
7409 E: serde::de::Error,
7410 {
7411 match value {
7412 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7413 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7414 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7415 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7416 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7417 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7418 }
7419 }
7420 }
7421 deserializer.deserialize_any(GeneratedVisitor)
7422 }
7423}
7424impl serde::Serialize for OverWindowNode {
7425 #[allow(deprecated)]
7426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7427 where
7428 S: serde::Serializer,
7429 {
7430 use serde::ser::SerializeStruct;
7431 let mut len = 0;
7432 if !self.calls.is_empty() {
7433 len += 1;
7434 }
7435 if !self.partition_by.is_empty() {
7436 len += 1;
7437 }
7438 if !self.order_by.is_empty() {
7439 len += 1;
7440 }
7441 if self.state_table.is_some() {
7442 len += 1;
7443 }
7444 if self.cache_policy != 0 {
7445 len += 1;
7446 }
7447 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7448 if !self.calls.is_empty() {
7449 struct_ser.serialize_field("calls", &self.calls)?;
7450 }
7451 if !self.partition_by.is_empty() {
7452 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7453 }
7454 if !self.order_by.is_empty() {
7455 struct_ser.serialize_field("orderBy", &self.order_by)?;
7456 }
7457 if let Some(v) = self.state_table.as_ref() {
7458 struct_ser.serialize_field("stateTable", v)?;
7459 }
7460 if self.cache_policy != 0 {
7461 let v = OverWindowCachePolicy::try_from(self.cache_policy)
7462 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7463 struct_ser.serialize_field("cachePolicy", &v)?;
7464 }
7465 struct_ser.end()
7466 }
7467}
7468impl<'de> serde::Deserialize<'de> for OverWindowNode {
7469 #[allow(deprecated)]
7470 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7471 where
7472 D: serde::Deserializer<'de>,
7473 {
7474 const FIELDS: &[&str] = &[
7475 "calls",
7476 "partition_by",
7477 "partitionBy",
7478 "order_by",
7479 "orderBy",
7480 "state_table",
7481 "stateTable",
7482 "cache_policy",
7483 "cachePolicy",
7484 ];
7485
7486 #[allow(clippy::enum_variant_names)]
7487 enum GeneratedField {
7488 Calls,
7489 PartitionBy,
7490 OrderBy,
7491 StateTable,
7492 CachePolicy,
7493 }
7494 impl<'de> serde::Deserialize<'de> for GeneratedField {
7495 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7496 where
7497 D: serde::Deserializer<'de>,
7498 {
7499 struct GeneratedVisitor;
7500
7501 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7502 type Value = GeneratedField;
7503
7504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7505 write!(formatter, "expected one of: {:?}", &FIELDS)
7506 }
7507
7508 #[allow(unused_variables)]
7509 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7510 where
7511 E: serde::de::Error,
7512 {
7513 match value {
7514 "calls" => Ok(GeneratedField::Calls),
7515 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7516 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7517 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7518 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7519 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7520 }
7521 }
7522 }
7523 deserializer.deserialize_identifier(GeneratedVisitor)
7524 }
7525 }
7526 struct GeneratedVisitor;
7527 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7528 type Value = OverWindowNode;
7529
7530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7531 formatter.write_str("struct stream_plan.OverWindowNode")
7532 }
7533
7534 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7535 where
7536 V: serde::de::MapAccess<'de>,
7537 {
7538 let mut calls__ = None;
7539 let mut partition_by__ = None;
7540 let mut order_by__ = None;
7541 let mut state_table__ = None;
7542 let mut cache_policy__ = None;
7543 while let Some(k) = map_.next_key()? {
7544 match k {
7545 GeneratedField::Calls => {
7546 if calls__.is_some() {
7547 return Err(serde::de::Error::duplicate_field("calls"));
7548 }
7549 calls__ = Some(map_.next_value()?);
7550 }
7551 GeneratedField::PartitionBy => {
7552 if partition_by__.is_some() {
7553 return Err(serde::de::Error::duplicate_field("partitionBy"));
7554 }
7555 partition_by__ =
7556 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7557 .into_iter().map(|x| x.0).collect())
7558 ;
7559 }
7560 GeneratedField::OrderBy => {
7561 if order_by__.is_some() {
7562 return Err(serde::de::Error::duplicate_field("orderBy"));
7563 }
7564 order_by__ = Some(map_.next_value()?);
7565 }
7566 GeneratedField::StateTable => {
7567 if state_table__.is_some() {
7568 return Err(serde::de::Error::duplicate_field("stateTable"));
7569 }
7570 state_table__ = map_.next_value()?;
7571 }
7572 GeneratedField::CachePolicy => {
7573 if cache_policy__.is_some() {
7574 return Err(serde::de::Error::duplicate_field("cachePolicy"));
7575 }
7576 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7577 }
7578 }
7579 }
7580 Ok(OverWindowNode {
7581 calls: calls__.unwrap_or_default(),
7582 partition_by: partition_by__.unwrap_or_default(),
7583 order_by: order_by__.unwrap_or_default(),
7584 state_table: state_table__,
7585 cache_policy: cache_policy__.unwrap_or_default(),
7586 })
7587 }
7588 }
7589 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7590 }
7591}
7592impl serde::Serialize for PauseMutation {
7593 #[allow(deprecated)]
7594 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7595 where
7596 S: serde::Serializer,
7597 {
7598 use serde::ser::SerializeStruct;
7599 let len = 0;
7600 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7601 struct_ser.end()
7602 }
7603}
7604impl<'de> serde::Deserialize<'de> for PauseMutation {
7605 #[allow(deprecated)]
7606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7607 where
7608 D: serde::Deserializer<'de>,
7609 {
7610 const FIELDS: &[&str] = &[
7611 ];
7612
7613 #[allow(clippy::enum_variant_names)]
7614 enum GeneratedField {
7615 }
7616 impl<'de> serde::Deserialize<'de> for GeneratedField {
7617 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7618 where
7619 D: serde::Deserializer<'de>,
7620 {
7621 struct GeneratedVisitor;
7622
7623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7624 type Value = GeneratedField;
7625
7626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7627 write!(formatter, "expected one of: {:?}", &FIELDS)
7628 }
7629
7630 #[allow(unused_variables)]
7631 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7632 where
7633 E: serde::de::Error,
7634 {
7635 Err(serde::de::Error::unknown_field(value, FIELDS))
7636 }
7637 }
7638 deserializer.deserialize_identifier(GeneratedVisitor)
7639 }
7640 }
7641 struct GeneratedVisitor;
7642 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7643 type Value = PauseMutation;
7644
7645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7646 formatter.write_str("struct stream_plan.PauseMutation")
7647 }
7648
7649 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7650 where
7651 V: serde::de::MapAccess<'de>,
7652 {
7653 while map_.next_key::<GeneratedField>()?.is_some() {
7654 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7655 }
7656 Ok(PauseMutation {
7657 })
7658 }
7659 }
7660 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7661 }
7662}
7663impl serde::Serialize for ProjectNode {
7664 #[allow(deprecated)]
7665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7666 where
7667 S: serde::Serializer,
7668 {
7669 use serde::ser::SerializeStruct;
7670 let mut len = 0;
7671 if !self.select_list.is_empty() {
7672 len += 1;
7673 }
7674 if !self.watermark_input_cols.is_empty() {
7675 len += 1;
7676 }
7677 if !self.watermark_output_cols.is_empty() {
7678 len += 1;
7679 }
7680 if !self.nondecreasing_exprs.is_empty() {
7681 len += 1;
7682 }
7683 if self.noop_update_hint {
7684 len += 1;
7685 }
7686 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7687 if !self.select_list.is_empty() {
7688 struct_ser.serialize_field("selectList", &self.select_list)?;
7689 }
7690 if !self.watermark_input_cols.is_empty() {
7691 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7692 }
7693 if !self.watermark_output_cols.is_empty() {
7694 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7695 }
7696 if !self.nondecreasing_exprs.is_empty() {
7697 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7698 }
7699 if self.noop_update_hint {
7700 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7701 }
7702 struct_ser.end()
7703 }
7704}
7705impl<'de> serde::Deserialize<'de> for ProjectNode {
7706 #[allow(deprecated)]
7707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7708 where
7709 D: serde::Deserializer<'de>,
7710 {
7711 const FIELDS: &[&str] = &[
7712 "select_list",
7713 "selectList",
7714 "watermark_input_cols",
7715 "watermarkInputCols",
7716 "watermark_output_cols",
7717 "watermarkOutputCols",
7718 "nondecreasing_exprs",
7719 "nondecreasingExprs",
7720 "noop_update_hint",
7721 "noopUpdateHint",
7722 ];
7723
7724 #[allow(clippy::enum_variant_names)]
7725 enum GeneratedField {
7726 SelectList,
7727 WatermarkInputCols,
7728 WatermarkOutputCols,
7729 NondecreasingExprs,
7730 NoopUpdateHint,
7731 }
7732 impl<'de> serde::Deserialize<'de> for GeneratedField {
7733 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7734 where
7735 D: serde::Deserializer<'de>,
7736 {
7737 struct GeneratedVisitor;
7738
7739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7740 type Value = GeneratedField;
7741
7742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7743 write!(formatter, "expected one of: {:?}", &FIELDS)
7744 }
7745
7746 #[allow(unused_variables)]
7747 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7748 where
7749 E: serde::de::Error,
7750 {
7751 match value {
7752 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7753 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7754 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7755 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7756 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7758 }
7759 }
7760 }
7761 deserializer.deserialize_identifier(GeneratedVisitor)
7762 }
7763 }
7764 struct GeneratedVisitor;
7765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7766 type Value = ProjectNode;
7767
7768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7769 formatter.write_str("struct stream_plan.ProjectNode")
7770 }
7771
7772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7773 where
7774 V: serde::de::MapAccess<'de>,
7775 {
7776 let mut select_list__ = None;
7777 let mut watermark_input_cols__ = None;
7778 let mut watermark_output_cols__ = None;
7779 let mut nondecreasing_exprs__ = None;
7780 let mut noop_update_hint__ = None;
7781 while let Some(k) = map_.next_key()? {
7782 match k {
7783 GeneratedField::SelectList => {
7784 if select_list__.is_some() {
7785 return Err(serde::de::Error::duplicate_field("selectList"));
7786 }
7787 select_list__ = Some(map_.next_value()?);
7788 }
7789 GeneratedField::WatermarkInputCols => {
7790 if watermark_input_cols__.is_some() {
7791 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7792 }
7793 watermark_input_cols__ =
7794 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7795 .into_iter().map(|x| x.0).collect())
7796 ;
7797 }
7798 GeneratedField::WatermarkOutputCols => {
7799 if watermark_output_cols__.is_some() {
7800 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7801 }
7802 watermark_output_cols__ =
7803 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7804 .into_iter().map(|x| x.0).collect())
7805 ;
7806 }
7807 GeneratedField::NondecreasingExprs => {
7808 if nondecreasing_exprs__.is_some() {
7809 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7810 }
7811 nondecreasing_exprs__ =
7812 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7813 .into_iter().map(|x| x.0).collect())
7814 ;
7815 }
7816 GeneratedField::NoopUpdateHint => {
7817 if noop_update_hint__.is_some() {
7818 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
7819 }
7820 noop_update_hint__ = Some(map_.next_value()?);
7821 }
7822 }
7823 }
7824 Ok(ProjectNode {
7825 select_list: select_list__.unwrap_or_default(),
7826 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7827 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
7828 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7829 noop_update_hint: noop_update_hint__.unwrap_or_default(),
7830 })
7831 }
7832 }
7833 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
7834 }
7835}
7836impl serde::Serialize for ProjectSetNode {
7837 #[allow(deprecated)]
7838 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7839 where
7840 S: serde::Serializer,
7841 {
7842 use serde::ser::SerializeStruct;
7843 let mut len = 0;
7844 if !self.select_list.is_empty() {
7845 len += 1;
7846 }
7847 if !self.watermark_input_cols.is_empty() {
7848 len += 1;
7849 }
7850 if !self.watermark_expr_indices.is_empty() {
7851 len += 1;
7852 }
7853 if !self.nondecreasing_exprs.is_empty() {
7854 len += 1;
7855 }
7856 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
7857 if !self.select_list.is_empty() {
7858 struct_ser.serialize_field("selectList", &self.select_list)?;
7859 }
7860 if !self.watermark_input_cols.is_empty() {
7861 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7862 }
7863 if !self.watermark_expr_indices.is_empty() {
7864 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
7865 }
7866 if !self.nondecreasing_exprs.is_empty() {
7867 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7868 }
7869 struct_ser.end()
7870 }
7871}
7872impl<'de> serde::Deserialize<'de> for ProjectSetNode {
7873 #[allow(deprecated)]
7874 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7875 where
7876 D: serde::Deserializer<'de>,
7877 {
7878 const FIELDS: &[&str] = &[
7879 "select_list",
7880 "selectList",
7881 "watermark_input_cols",
7882 "watermarkInputCols",
7883 "watermark_expr_indices",
7884 "watermarkExprIndices",
7885 "nondecreasing_exprs",
7886 "nondecreasingExprs",
7887 ];
7888
7889 #[allow(clippy::enum_variant_names)]
7890 enum GeneratedField {
7891 SelectList,
7892 WatermarkInputCols,
7893 WatermarkExprIndices,
7894 NondecreasingExprs,
7895 }
7896 impl<'de> serde::Deserialize<'de> for GeneratedField {
7897 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7898 where
7899 D: serde::Deserializer<'de>,
7900 {
7901 struct GeneratedVisitor;
7902
7903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7904 type Value = GeneratedField;
7905
7906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7907 write!(formatter, "expected one of: {:?}", &FIELDS)
7908 }
7909
7910 #[allow(unused_variables)]
7911 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7912 where
7913 E: serde::de::Error,
7914 {
7915 match value {
7916 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7917 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7918 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
7919 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7920 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7921 }
7922 }
7923 }
7924 deserializer.deserialize_identifier(GeneratedVisitor)
7925 }
7926 }
7927 struct GeneratedVisitor;
7928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7929 type Value = ProjectSetNode;
7930
7931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7932 formatter.write_str("struct stream_plan.ProjectSetNode")
7933 }
7934
7935 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
7936 where
7937 V: serde::de::MapAccess<'de>,
7938 {
7939 let mut select_list__ = None;
7940 let mut watermark_input_cols__ = None;
7941 let mut watermark_expr_indices__ = None;
7942 let mut nondecreasing_exprs__ = None;
7943 while let Some(k) = map_.next_key()? {
7944 match k {
7945 GeneratedField::SelectList => {
7946 if select_list__.is_some() {
7947 return Err(serde::de::Error::duplicate_field("selectList"));
7948 }
7949 select_list__ = Some(map_.next_value()?);
7950 }
7951 GeneratedField::WatermarkInputCols => {
7952 if watermark_input_cols__.is_some() {
7953 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7954 }
7955 watermark_input_cols__ =
7956 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7957 .into_iter().map(|x| x.0).collect())
7958 ;
7959 }
7960 GeneratedField::WatermarkExprIndices => {
7961 if watermark_expr_indices__.is_some() {
7962 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
7963 }
7964 watermark_expr_indices__ =
7965 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7966 .into_iter().map(|x| x.0).collect())
7967 ;
7968 }
7969 GeneratedField::NondecreasingExprs => {
7970 if nondecreasing_exprs__.is_some() {
7971 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7972 }
7973 nondecreasing_exprs__ =
7974 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7975 .into_iter().map(|x| x.0).collect())
7976 ;
7977 }
7978 }
7979 }
7980 Ok(ProjectSetNode {
7981 select_list: select_list__.unwrap_or_default(),
7982 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7983 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
7984 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7985 })
7986 }
7987 }
7988 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
7989 }
7990}
7991impl serde::Serialize for RefreshStartMutation {
7992 #[allow(deprecated)]
7993 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7994 where
7995 S: serde::Serializer,
7996 {
7997 use serde::ser::SerializeStruct;
7998 let mut len = 0;
7999 if self.table_id != 0 {
8000 len += 1;
8001 }
8002 if self.associated_source_id != 0 {
8003 len += 1;
8004 }
8005 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8006 if self.table_id != 0 {
8007 struct_ser.serialize_field("tableId", &self.table_id)?;
8008 }
8009 if self.associated_source_id != 0 {
8010 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8011 }
8012 struct_ser.end()
8013 }
8014}
8015impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8016 #[allow(deprecated)]
8017 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8018 where
8019 D: serde::Deserializer<'de>,
8020 {
8021 const FIELDS: &[&str] = &[
8022 "table_id",
8023 "tableId",
8024 "associated_source_id",
8025 "associatedSourceId",
8026 ];
8027
8028 #[allow(clippy::enum_variant_names)]
8029 enum GeneratedField {
8030 TableId,
8031 AssociatedSourceId,
8032 }
8033 impl<'de> serde::Deserialize<'de> for GeneratedField {
8034 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8035 where
8036 D: serde::Deserializer<'de>,
8037 {
8038 struct GeneratedVisitor;
8039
8040 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8041 type Value = GeneratedField;
8042
8043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8044 write!(formatter, "expected one of: {:?}", &FIELDS)
8045 }
8046
8047 #[allow(unused_variables)]
8048 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8049 where
8050 E: serde::de::Error,
8051 {
8052 match value {
8053 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8054 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8055 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8056 }
8057 }
8058 }
8059 deserializer.deserialize_identifier(GeneratedVisitor)
8060 }
8061 }
8062 struct GeneratedVisitor;
8063 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8064 type Value = RefreshStartMutation;
8065
8066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8067 formatter.write_str("struct stream_plan.RefreshStartMutation")
8068 }
8069
8070 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8071 where
8072 V: serde::de::MapAccess<'de>,
8073 {
8074 let mut table_id__ = None;
8075 let mut associated_source_id__ = None;
8076 while let Some(k) = map_.next_key()? {
8077 match k {
8078 GeneratedField::TableId => {
8079 if table_id__.is_some() {
8080 return Err(serde::de::Error::duplicate_field("tableId"));
8081 }
8082 table_id__ =
8083 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8084 ;
8085 }
8086 GeneratedField::AssociatedSourceId => {
8087 if associated_source_id__.is_some() {
8088 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8089 }
8090 associated_source_id__ =
8091 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8092 ;
8093 }
8094 }
8095 }
8096 Ok(RefreshStartMutation {
8097 table_id: table_id__.unwrap_or_default(),
8098 associated_source_id: associated_source_id__.unwrap_or_default(),
8099 })
8100 }
8101 }
8102 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8103 }
8104}
8105impl serde::Serialize for ResumeMutation {
8106 #[allow(deprecated)]
8107 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8108 where
8109 S: serde::Serializer,
8110 {
8111 use serde::ser::SerializeStruct;
8112 let len = 0;
8113 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8114 struct_ser.end()
8115 }
8116}
8117impl<'de> serde::Deserialize<'de> for ResumeMutation {
8118 #[allow(deprecated)]
8119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8120 where
8121 D: serde::Deserializer<'de>,
8122 {
8123 const FIELDS: &[&str] = &[
8124 ];
8125
8126 #[allow(clippy::enum_variant_names)]
8127 enum GeneratedField {
8128 }
8129 impl<'de> serde::Deserialize<'de> for GeneratedField {
8130 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8131 where
8132 D: serde::Deserializer<'de>,
8133 {
8134 struct GeneratedVisitor;
8135
8136 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8137 type Value = GeneratedField;
8138
8139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8140 write!(formatter, "expected one of: {:?}", &FIELDS)
8141 }
8142
8143 #[allow(unused_variables)]
8144 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8145 where
8146 E: serde::de::Error,
8147 {
8148 Err(serde::de::Error::unknown_field(value, FIELDS))
8149 }
8150 }
8151 deserializer.deserialize_identifier(GeneratedVisitor)
8152 }
8153 }
8154 struct GeneratedVisitor;
8155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8156 type Value = ResumeMutation;
8157
8158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8159 formatter.write_str("struct stream_plan.ResumeMutation")
8160 }
8161
8162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
8163 where
8164 V: serde::de::MapAccess<'de>,
8165 {
8166 while map_.next_key::<GeneratedField>()?.is_some() {
8167 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8168 }
8169 Ok(ResumeMutation {
8170 })
8171 }
8172 }
8173 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
8174 }
8175}
8176impl serde::Serialize for RowIdGenNode {
8177 #[allow(deprecated)]
8178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8179 where
8180 S: serde::Serializer,
8181 {
8182 use serde::ser::SerializeStruct;
8183 let mut len = 0;
8184 if self.row_id_index != 0 {
8185 len += 1;
8186 }
8187 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
8188 if self.row_id_index != 0 {
8189 #[allow(clippy::needless_borrow)]
8190 #[allow(clippy::needless_borrows_for_generic_args)]
8191 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
8192 }
8193 struct_ser.end()
8194 }
8195}
8196impl<'de> serde::Deserialize<'de> for RowIdGenNode {
8197 #[allow(deprecated)]
8198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8199 where
8200 D: serde::Deserializer<'de>,
8201 {
8202 const FIELDS: &[&str] = &[
8203 "row_id_index",
8204 "rowIdIndex",
8205 ];
8206
8207 #[allow(clippy::enum_variant_names)]
8208 enum GeneratedField {
8209 RowIdIndex,
8210 }
8211 impl<'de> serde::Deserialize<'de> for GeneratedField {
8212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8213 where
8214 D: serde::Deserializer<'de>,
8215 {
8216 struct GeneratedVisitor;
8217
8218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8219 type Value = GeneratedField;
8220
8221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8222 write!(formatter, "expected one of: {:?}", &FIELDS)
8223 }
8224
8225 #[allow(unused_variables)]
8226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8227 where
8228 E: serde::de::Error,
8229 {
8230 match value {
8231 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8232 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8233 }
8234 }
8235 }
8236 deserializer.deserialize_identifier(GeneratedVisitor)
8237 }
8238 }
8239 struct GeneratedVisitor;
8240 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8241 type Value = RowIdGenNode;
8242
8243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8244 formatter.write_str("struct stream_plan.RowIdGenNode")
8245 }
8246
8247 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
8248 where
8249 V: serde::de::MapAccess<'de>,
8250 {
8251 let mut row_id_index__ = None;
8252 while let Some(k) = map_.next_key()? {
8253 match k {
8254 GeneratedField::RowIdIndex => {
8255 if row_id_index__.is_some() {
8256 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
8257 }
8258 row_id_index__ =
8259 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8260 ;
8261 }
8262 }
8263 }
8264 Ok(RowIdGenNode {
8265 row_id_index: row_id_index__.unwrap_or_default(),
8266 })
8267 }
8268 }
8269 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
8270 }
8271}
8272impl serde::Serialize for RowMergeNode {
8273 #[allow(deprecated)]
8274 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8275 where
8276 S: serde::Serializer,
8277 {
8278 use serde::ser::SerializeStruct;
8279 let mut len = 0;
8280 if self.lhs_mapping.is_some() {
8281 len += 1;
8282 }
8283 if self.rhs_mapping.is_some() {
8284 len += 1;
8285 }
8286 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
8287 if let Some(v) = self.lhs_mapping.as_ref() {
8288 struct_ser.serialize_field("lhsMapping", v)?;
8289 }
8290 if let Some(v) = self.rhs_mapping.as_ref() {
8291 struct_ser.serialize_field("rhsMapping", v)?;
8292 }
8293 struct_ser.end()
8294 }
8295}
8296impl<'de> serde::Deserialize<'de> for RowMergeNode {
8297 #[allow(deprecated)]
8298 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8299 where
8300 D: serde::Deserializer<'de>,
8301 {
8302 const FIELDS: &[&str] = &[
8303 "lhs_mapping",
8304 "lhsMapping",
8305 "rhs_mapping",
8306 "rhsMapping",
8307 ];
8308
8309 #[allow(clippy::enum_variant_names)]
8310 enum GeneratedField {
8311 LhsMapping,
8312 RhsMapping,
8313 }
8314 impl<'de> serde::Deserialize<'de> for GeneratedField {
8315 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8316 where
8317 D: serde::Deserializer<'de>,
8318 {
8319 struct GeneratedVisitor;
8320
8321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8322 type Value = GeneratedField;
8323
8324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8325 write!(formatter, "expected one of: {:?}", &FIELDS)
8326 }
8327
8328 #[allow(unused_variables)]
8329 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8330 where
8331 E: serde::de::Error,
8332 {
8333 match value {
8334 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
8335 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
8336 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8337 }
8338 }
8339 }
8340 deserializer.deserialize_identifier(GeneratedVisitor)
8341 }
8342 }
8343 struct GeneratedVisitor;
8344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8345 type Value = RowMergeNode;
8346
8347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8348 formatter.write_str("struct stream_plan.RowMergeNode")
8349 }
8350
8351 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
8352 where
8353 V: serde::de::MapAccess<'de>,
8354 {
8355 let mut lhs_mapping__ = None;
8356 let mut rhs_mapping__ = None;
8357 while let Some(k) = map_.next_key()? {
8358 match k {
8359 GeneratedField::LhsMapping => {
8360 if lhs_mapping__.is_some() {
8361 return Err(serde::de::Error::duplicate_field("lhsMapping"));
8362 }
8363 lhs_mapping__ = map_.next_value()?;
8364 }
8365 GeneratedField::RhsMapping => {
8366 if rhs_mapping__.is_some() {
8367 return Err(serde::de::Error::duplicate_field("rhsMapping"));
8368 }
8369 rhs_mapping__ = map_.next_value()?;
8370 }
8371 }
8372 }
8373 Ok(RowMergeNode {
8374 lhs_mapping: lhs_mapping__,
8375 rhs_mapping: rhs_mapping__,
8376 })
8377 }
8378 }
8379 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8380 }
8381}
8382impl serde::Serialize for SimpleAggNode {
8383 #[allow(deprecated)]
8384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8385 where
8386 S: serde::Serializer,
8387 {
8388 use serde::ser::SerializeStruct;
8389 let mut len = 0;
8390 if !self.agg_calls.is_empty() {
8391 len += 1;
8392 }
8393 if !self.agg_call_states.is_empty() {
8394 len += 1;
8395 }
8396 if self.intermediate_state_table.is_some() {
8397 len += 1;
8398 }
8399 if self.is_append_only {
8400 len += 1;
8401 }
8402 if !self.distinct_dedup_tables.is_empty() {
8403 len += 1;
8404 }
8405 if self.row_count_index != 0 {
8406 len += 1;
8407 }
8408 if self.version != 0 {
8409 len += 1;
8410 }
8411 if self.must_output_per_barrier {
8412 len += 1;
8413 }
8414 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8415 if !self.agg_calls.is_empty() {
8416 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8417 }
8418 if !self.agg_call_states.is_empty() {
8419 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8420 }
8421 if let Some(v) = self.intermediate_state_table.as_ref() {
8422 struct_ser.serialize_field("intermediateStateTable", v)?;
8423 }
8424 if self.is_append_only {
8425 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8426 }
8427 if !self.distinct_dedup_tables.is_empty() {
8428 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8429 }
8430 if self.row_count_index != 0 {
8431 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8432 }
8433 if self.version != 0 {
8434 let v = AggNodeVersion::try_from(self.version)
8435 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8436 struct_ser.serialize_field("version", &v)?;
8437 }
8438 if self.must_output_per_barrier {
8439 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8440 }
8441 struct_ser.end()
8442 }
8443}
8444impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8445 #[allow(deprecated)]
8446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8447 where
8448 D: serde::Deserializer<'de>,
8449 {
8450 const FIELDS: &[&str] = &[
8451 "agg_calls",
8452 "aggCalls",
8453 "agg_call_states",
8454 "aggCallStates",
8455 "intermediate_state_table",
8456 "intermediateStateTable",
8457 "is_append_only",
8458 "isAppendOnly",
8459 "distinct_dedup_tables",
8460 "distinctDedupTables",
8461 "row_count_index",
8462 "rowCountIndex",
8463 "version",
8464 "must_output_per_barrier",
8465 "mustOutputPerBarrier",
8466 ];
8467
8468 #[allow(clippy::enum_variant_names)]
8469 enum GeneratedField {
8470 AggCalls,
8471 AggCallStates,
8472 IntermediateStateTable,
8473 IsAppendOnly,
8474 DistinctDedupTables,
8475 RowCountIndex,
8476 Version,
8477 MustOutputPerBarrier,
8478 }
8479 impl<'de> serde::Deserialize<'de> for GeneratedField {
8480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8481 where
8482 D: serde::Deserializer<'de>,
8483 {
8484 struct GeneratedVisitor;
8485
8486 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8487 type Value = GeneratedField;
8488
8489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8490 write!(formatter, "expected one of: {:?}", &FIELDS)
8491 }
8492
8493 #[allow(unused_variables)]
8494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8495 where
8496 E: serde::de::Error,
8497 {
8498 match value {
8499 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8500 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8501 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8502 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8503 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8504 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8505 "version" => Ok(GeneratedField::Version),
8506 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8507 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8508 }
8509 }
8510 }
8511 deserializer.deserialize_identifier(GeneratedVisitor)
8512 }
8513 }
8514 struct GeneratedVisitor;
8515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8516 type Value = SimpleAggNode;
8517
8518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8519 formatter.write_str("struct stream_plan.SimpleAggNode")
8520 }
8521
8522 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8523 where
8524 V: serde::de::MapAccess<'de>,
8525 {
8526 let mut agg_calls__ = None;
8527 let mut agg_call_states__ = None;
8528 let mut intermediate_state_table__ = None;
8529 let mut is_append_only__ = None;
8530 let mut distinct_dedup_tables__ = None;
8531 let mut row_count_index__ = None;
8532 let mut version__ = None;
8533 let mut must_output_per_barrier__ = None;
8534 while let Some(k) = map_.next_key()? {
8535 match k {
8536 GeneratedField::AggCalls => {
8537 if agg_calls__.is_some() {
8538 return Err(serde::de::Error::duplicate_field("aggCalls"));
8539 }
8540 agg_calls__ = Some(map_.next_value()?);
8541 }
8542 GeneratedField::AggCallStates => {
8543 if agg_call_states__.is_some() {
8544 return Err(serde::de::Error::duplicate_field("aggCallStates"));
8545 }
8546 agg_call_states__ = Some(map_.next_value()?);
8547 }
8548 GeneratedField::IntermediateStateTable => {
8549 if intermediate_state_table__.is_some() {
8550 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8551 }
8552 intermediate_state_table__ = map_.next_value()?;
8553 }
8554 GeneratedField::IsAppendOnly => {
8555 if is_append_only__.is_some() {
8556 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8557 }
8558 is_append_only__ = Some(map_.next_value()?);
8559 }
8560 GeneratedField::DistinctDedupTables => {
8561 if distinct_dedup_tables__.is_some() {
8562 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8563 }
8564 distinct_dedup_tables__ = Some(
8565 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8566 .into_iter().map(|(k,v)| (k.0, v)).collect()
8567 );
8568 }
8569 GeneratedField::RowCountIndex => {
8570 if row_count_index__.is_some() {
8571 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8572 }
8573 row_count_index__ =
8574 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8575 ;
8576 }
8577 GeneratedField::Version => {
8578 if version__.is_some() {
8579 return Err(serde::de::Error::duplicate_field("version"));
8580 }
8581 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8582 }
8583 GeneratedField::MustOutputPerBarrier => {
8584 if must_output_per_barrier__.is_some() {
8585 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8586 }
8587 must_output_per_barrier__ = Some(map_.next_value()?);
8588 }
8589 }
8590 }
8591 Ok(SimpleAggNode {
8592 agg_calls: agg_calls__.unwrap_or_default(),
8593 agg_call_states: agg_call_states__.unwrap_or_default(),
8594 intermediate_state_table: intermediate_state_table__,
8595 is_append_only: is_append_only__.unwrap_or_default(),
8596 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8597 row_count_index: row_count_index__.unwrap_or_default(),
8598 version: version__.unwrap_or_default(),
8599 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8600 })
8601 }
8602 }
8603 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8604 }
8605}
8606impl serde::Serialize for SinkDesc {
8607 #[allow(deprecated)]
8608 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8609 where
8610 S: serde::Serializer,
8611 {
8612 use serde::ser::SerializeStruct;
8613 let mut len = 0;
8614 if self.id != 0 {
8615 len += 1;
8616 }
8617 if !self.name.is_empty() {
8618 len += 1;
8619 }
8620 if !self.definition.is_empty() {
8621 len += 1;
8622 }
8623 if !self.plan_pk.is_empty() {
8624 len += 1;
8625 }
8626 if !self.downstream_pk.is_empty() {
8627 len += 1;
8628 }
8629 if !self.distribution_key.is_empty() {
8630 len += 1;
8631 }
8632 if !self.properties.is_empty() {
8633 len += 1;
8634 }
8635 if self.sink_type != 0 {
8636 len += 1;
8637 }
8638 if !self.column_catalogs.is_empty() {
8639 len += 1;
8640 }
8641 if !self.db_name.is_empty() {
8642 len += 1;
8643 }
8644 if !self.sink_from_name.is_empty() {
8645 len += 1;
8646 }
8647 if self.format_desc.is_some() {
8648 len += 1;
8649 }
8650 if self.target_table.is_some() {
8651 len += 1;
8652 }
8653 if self.extra_partition_col_idx.is_some() {
8654 len += 1;
8655 }
8656 if !self.secret_refs.is_empty() {
8657 len += 1;
8658 }
8659 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8660 if self.id != 0 {
8661 struct_ser.serialize_field("id", &self.id)?;
8662 }
8663 if !self.name.is_empty() {
8664 struct_ser.serialize_field("name", &self.name)?;
8665 }
8666 if !self.definition.is_empty() {
8667 struct_ser.serialize_field("definition", &self.definition)?;
8668 }
8669 if !self.plan_pk.is_empty() {
8670 struct_ser.serialize_field("planPk", &self.plan_pk)?;
8671 }
8672 if !self.downstream_pk.is_empty() {
8673 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8674 }
8675 if !self.distribution_key.is_empty() {
8676 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8677 }
8678 if !self.properties.is_empty() {
8679 struct_ser.serialize_field("properties", &self.properties)?;
8680 }
8681 if self.sink_type != 0 {
8682 let v = super::catalog::SinkType::try_from(self.sink_type)
8683 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8684 struct_ser.serialize_field("sinkType", &v)?;
8685 }
8686 if !self.column_catalogs.is_empty() {
8687 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8688 }
8689 if !self.db_name.is_empty() {
8690 struct_ser.serialize_field("dbName", &self.db_name)?;
8691 }
8692 if !self.sink_from_name.is_empty() {
8693 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8694 }
8695 if let Some(v) = self.format_desc.as_ref() {
8696 struct_ser.serialize_field("formatDesc", v)?;
8697 }
8698 if let Some(v) = self.target_table.as_ref() {
8699 struct_ser.serialize_field("targetTable", v)?;
8700 }
8701 if let Some(v) = self.extra_partition_col_idx.as_ref() {
8702 #[allow(clippy::needless_borrow)]
8703 #[allow(clippy::needless_borrows_for_generic_args)]
8704 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8705 }
8706 if !self.secret_refs.is_empty() {
8707 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8708 }
8709 struct_ser.end()
8710 }
8711}
8712impl<'de> serde::Deserialize<'de> for SinkDesc {
8713 #[allow(deprecated)]
8714 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8715 where
8716 D: serde::Deserializer<'de>,
8717 {
8718 const FIELDS: &[&str] = &[
8719 "id",
8720 "name",
8721 "definition",
8722 "plan_pk",
8723 "planPk",
8724 "downstream_pk",
8725 "downstreamPk",
8726 "distribution_key",
8727 "distributionKey",
8728 "properties",
8729 "sink_type",
8730 "sinkType",
8731 "column_catalogs",
8732 "columnCatalogs",
8733 "db_name",
8734 "dbName",
8735 "sink_from_name",
8736 "sinkFromName",
8737 "format_desc",
8738 "formatDesc",
8739 "target_table",
8740 "targetTable",
8741 "extra_partition_col_idx",
8742 "extraPartitionColIdx",
8743 "secret_refs",
8744 "secretRefs",
8745 ];
8746
8747 #[allow(clippy::enum_variant_names)]
8748 enum GeneratedField {
8749 Id,
8750 Name,
8751 Definition,
8752 PlanPk,
8753 DownstreamPk,
8754 DistributionKey,
8755 Properties,
8756 SinkType,
8757 ColumnCatalogs,
8758 DbName,
8759 SinkFromName,
8760 FormatDesc,
8761 TargetTable,
8762 ExtraPartitionColIdx,
8763 SecretRefs,
8764 }
8765 impl<'de> serde::Deserialize<'de> for GeneratedField {
8766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8767 where
8768 D: serde::Deserializer<'de>,
8769 {
8770 struct GeneratedVisitor;
8771
8772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8773 type Value = GeneratedField;
8774
8775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8776 write!(formatter, "expected one of: {:?}", &FIELDS)
8777 }
8778
8779 #[allow(unused_variables)]
8780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8781 where
8782 E: serde::de::Error,
8783 {
8784 match value {
8785 "id" => Ok(GeneratedField::Id),
8786 "name" => Ok(GeneratedField::Name),
8787 "definition" => Ok(GeneratedField::Definition),
8788 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
8789 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
8790 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8791 "properties" => Ok(GeneratedField::Properties),
8792 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
8793 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
8794 "dbName" | "db_name" => Ok(GeneratedField::DbName),
8795 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
8796 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
8797 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
8798 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
8799 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
8800 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8801 }
8802 }
8803 }
8804 deserializer.deserialize_identifier(GeneratedVisitor)
8805 }
8806 }
8807 struct GeneratedVisitor;
8808 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8809 type Value = SinkDesc;
8810
8811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8812 formatter.write_str("struct stream_plan.SinkDesc")
8813 }
8814
8815 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
8816 where
8817 V: serde::de::MapAccess<'de>,
8818 {
8819 let mut id__ = None;
8820 let mut name__ = None;
8821 let mut definition__ = None;
8822 let mut plan_pk__ = None;
8823 let mut downstream_pk__ = None;
8824 let mut distribution_key__ = None;
8825 let mut properties__ = None;
8826 let mut sink_type__ = None;
8827 let mut column_catalogs__ = None;
8828 let mut db_name__ = None;
8829 let mut sink_from_name__ = None;
8830 let mut format_desc__ = None;
8831 let mut target_table__ = None;
8832 let mut extra_partition_col_idx__ = None;
8833 let mut secret_refs__ = None;
8834 while let Some(k) = map_.next_key()? {
8835 match k {
8836 GeneratedField::Id => {
8837 if id__.is_some() {
8838 return Err(serde::de::Error::duplicate_field("id"));
8839 }
8840 id__ =
8841 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8842 ;
8843 }
8844 GeneratedField::Name => {
8845 if name__.is_some() {
8846 return Err(serde::de::Error::duplicate_field("name"));
8847 }
8848 name__ = Some(map_.next_value()?);
8849 }
8850 GeneratedField::Definition => {
8851 if definition__.is_some() {
8852 return Err(serde::de::Error::duplicate_field("definition"));
8853 }
8854 definition__ = Some(map_.next_value()?);
8855 }
8856 GeneratedField::PlanPk => {
8857 if plan_pk__.is_some() {
8858 return Err(serde::de::Error::duplicate_field("planPk"));
8859 }
8860 plan_pk__ = Some(map_.next_value()?);
8861 }
8862 GeneratedField::DownstreamPk => {
8863 if downstream_pk__.is_some() {
8864 return Err(serde::de::Error::duplicate_field("downstreamPk"));
8865 }
8866 downstream_pk__ =
8867 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8868 .into_iter().map(|x| x.0).collect())
8869 ;
8870 }
8871 GeneratedField::DistributionKey => {
8872 if distribution_key__.is_some() {
8873 return Err(serde::de::Error::duplicate_field("distributionKey"));
8874 }
8875 distribution_key__ =
8876 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8877 .into_iter().map(|x| x.0).collect())
8878 ;
8879 }
8880 GeneratedField::Properties => {
8881 if properties__.is_some() {
8882 return Err(serde::de::Error::duplicate_field("properties"));
8883 }
8884 properties__ = Some(
8885 map_.next_value::<std::collections::BTreeMap<_, _>>()?
8886 );
8887 }
8888 GeneratedField::SinkType => {
8889 if sink_type__.is_some() {
8890 return Err(serde::de::Error::duplicate_field("sinkType"));
8891 }
8892 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
8893 }
8894 GeneratedField::ColumnCatalogs => {
8895 if column_catalogs__.is_some() {
8896 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
8897 }
8898 column_catalogs__ = Some(map_.next_value()?);
8899 }
8900 GeneratedField::DbName => {
8901 if db_name__.is_some() {
8902 return Err(serde::de::Error::duplicate_field("dbName"));
8903 }
8904 db_name__ = Some(map_.next_value()?);
8905 }
8906 GeneratedField::SinkFromName => {
8907 if sink_from_name__.is_some() {
8908 return Err(serde::de::Error::duplicate_field("sinkFromName"));
8909 }
8910 sink_from_name__ = Some(map_.next_value()?);
8911 }
8912 GeneratedField::FormatDesc => {
8913 if format_desc__.is_some() {
8914 return Err(serde::de::Error::duplicate_field("formatDesc"));
8915 }
8916 format_desc__ = map_.next_value()?;
8917 }
8918 GeneratedField::TargetTable => {
8919 if target_table__.is_some() {
8920 return Err(serde::de::Error::duplicate_field("targetTable"));
8921 }
8922 target_table__ =
8923 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8924 ;
8925 }
8926 GeneratedField::ExtraPartitionColIdx => {
8927 if extra_partition_col_idx__.is_some() {
8928 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
8929 }
8930 extra_partition_col_idx__ =
8931 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8932 ;
8933 }
8934 GeneratedField::SecretRefs => {
8935 if secret_refs__.is_some() {
8936 return Err(serde::de::Error::duplicate_field("secretRefs"));
8937 }
8938 secret_refs__ = Some(
8939 map_.next_value::<std::collections::BTreeMap<_, _>>()?
8940 );
8941 }
8942 }
8943 }
8944 Ok(SinkDesc {
8945 id: id__.unwrap_or_default(),
8946 name: name__.unwrap_or_default(),
8947 definition: definition__.unwrap_or_default(),
8948 plan_pk: plan_pk__.unwrap_or_default(),
8949 downstream_pk: downstream_pk__.unwrap_or_default(),
8950 distribution_key: distribution_key__.unwrap_or_default(),
8951 properties: properties__.unwrap_or_default(),
8952 sink_type: sink_type__.unwrap_or_default(),
8953 column_catalogs: column_catalogs__.unwrap_or_default(),
8954 db_name: db_name__.unwrap_or_default(),
8955 sink_from_name: sink_from_name__.unwrap_or_default(),
8956 format_desc: format_desc__,
8957 target_table: target_table__,
8958 extra_partition_col_idx: extra_partition_col_idx__,
8959 secret_refs: secret_refs__.unwrap_or_default(),
8960 })
8961 }
8962 }
8963 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
8964 }
8965}
8966impl serde::Serialize for SinkLogStoreType {
8967 #[allow(deprecated)]
8968 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8969 where
8970 S: serde::Serializer,
8971 {
8972 let variant = match self {
8973 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8974 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8975 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8976 };
8977 serializer.serialize_str(variant)
8978 }
8979}
8980impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
8981 #[allow(deprecated)]
8982 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8983 where
8984 D: serde::Deserializer<'de>,
8985 {
8986 const FIELDS: &[&str] = &[
8987 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8988 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8989 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8990 ];
8991
8992 struct GeneratedVisitor;
8993
8994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8995 type Value = SinkLogStoreType;
8996
8997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8998 write!(formatter, "expected one of: {:?}", &FIELDS)
8999 }
9000
9001 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9002 where
9003 E: serde::de::Error,
9004 {
9005 i32::try_from(v)
9006 .ok()
9007 .and_then(|x| x.try_into().ok())
9008 .ok_or_else(|| {
9009 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9010 })
9011 }
9012
9013 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9014 where
9015 E: serde::de::Error,
9016 {
9017 i32::try_from(v)
9018 .ok()
9019 .and_then(|x| x.try_into().ok())
9020 .ok_or_else(|| {
9021 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9022 })
9023 }
9024
9025 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9026 where
9027 E: serde::de::Error,
9028 {
9029 match value {
9030 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9031 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9032 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9033 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9034 }
9035 }
9036 }
9037 deserializer.deserialize_any(GeneratedVisitor)
9038 }
9039}
9040impl serde::Serialize for SinkNode {
9041 #[allow(deprecated)]
9042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9043 where
9044 S: serde::Serializer,
9045 {
9046 use serde::ser::SerializeStruct;
9047 let mut len = 0;
9048 if self.sink_desc.is_some() {
9049 len += 1;
9050 }
9051 if self.table.is_some() {
9052 len += 1;
9053 }
9054 if self.log_store_type != 0 {
9055 len += 1;
9056 }
9057 if self.rate_limit.is_some() {
9058 len += 1;
9059 }
9060 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
9061 if let Some(v) = self.sink_desc.as_ref() {
9062 struct_ser.serialize_field("sinkDesc", v)?;
9063 }
9064 if let Some(v) = self.table.as_ref() {
9065 struct_ser.serialize_field("table", v)?;
9066 }
9067 if self.log_store_type != 0 {
9068 let v = SinkLogStoreType::try_from(self.log_store_type)
9069 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
9070 struct_ser.serialize_field("logStoreType", &v)?;
9071 }
9072 if let Some(v) = self.rate_limit.as_ref() {
9073 struct_ser.serialize_field("rateLimit", v)?;
9074 }
9075 struct_ser.end()
9076 }
9077}
9078impl<'de> serde::Deserialize<'de> for SinkNode {
9079 #[allow(deprecated)]
9080 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9081 where
9082 D: serde::Deserializer<'de>,
9083 {
9084 const FIELDS: &[&str] = &[
9085 "sink_desc",
9086 "sinkDesc",
9087 "table",
9088 "log_store_type",
9089 "logStoreType",
9090 "rate_limit",
9091 "rateLimit",
9092 ];
9093
9094 #[allow(clippy::enum_variant_names)]
9095 enum GeneratedField {
9096 SinkDesc,
9097 Table,
9098 LogStoreType,
9099 RateLimit,
9100 }
9101 impl<'de> serde::Deserialize<'de> for GeneratedField {
9102 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9103 where
9104 D: serde::Deserializer<'de>,
9105 {
9106 struct GeneratedVisitor;
9107
9108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9109 type Value = GeneratedField;
9110
9111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9112 write!(formatter, "expected one of: {:?}", &FIELDS)
9113 }
9114
9115 #[allow(unused_variables)]
9116 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9117 where
9118 E: serde::de::Error,
9119 {
9120 match value {
9121 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
9122 "table" => Ok(GeneratedField::Table),
9123 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
9124 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9125 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9126 }
9127 }
9128 }
9129 deserializer.deserialize_identifier(GeneratedVisitor)
9130 }
9131 }
9132 struct GeneratedVisitor;
9133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9134 type Value = SinkNode;
9135
9136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9137 formatter.write_str("struct stream_plan.SinkNode")
9138 }
9139
9140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
9141 where
9142 V: serde::de::MapAccess<'de>,
9143 {
9144 let mut sink_desc__ = None;
9145 let mut table__ = None;
9146 let mut log_store_type__ = None;
9147 let mut rate_limit__ = None;
9148 while let Some(k) = map_.next_key()? {
9149 match k {
9150 GeneratedField::SinkDesc => {
9151 if sink_desc__.is_some() {
9152 return Err(serde::de::Error::duplicate_field("sinkDesc"));
9153 }
9154 sink_desc__ = map_.next_value()?;
9155 }
9156 GeneratedField::Table => {
9157 if table__.is_some() {
9158 return Err(serde::de::Error::duplicate_field("table"));
9159 }
9160 table__ = map_.next_value()?;
9161 }
9162 GeneratedField::LogStoreType => {
9163 if log_store_type__.is_some() {
9164 return Err(serde::de::Error::duplicate_field("logStoreType"));
9165 }
9166 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
9167 }
9168 GeneratedField::RateLimit => {
9169 if rate_limit__.is_some() {
9170 return Err(serde::de::Error::duplicate_field("rateLimit"));
9171 }
9172 rate_limit__ =
9173 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9174 ;
9175 }
9176 }
9177 }
9178 Ok(SinkNode {
9179 sink_desc: sink_desc__,
9180 table: table__,
9181 log_store_type: log_store_type__.unwrap_or_default(),
9182 rate_limit: rate_limit__,
9183 })
9184 }
9185 }
9186 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
9187 }
9188}
9189impl serde::Serialize for SortNode {
9190 #[allow(deprecated)]
9191 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9192 where
9193 S: serde::Serializer,
9194 {
9195 use serde::ser::SerializeStruct;
9196 let mut len = 0;
9197 if self.state_table.is_some() {
9198 len += 1;
9199 }
9200 if self.sort_column_index != 0 {
9201 len += 1;
9202 }
9203 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
9204 if let Some(v) = self.state_table.as_ref() {
9205 struct_ser.serialize_field("stateTable", v)?;
9206 }
9207 if self.sort_column_index != 0 {
9208 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
9209 }
9210 struct_ser.end()
9211 }
9212}
9213impl<'de> serde::Deserialize<'de> for SortNode {
9214 #[allow(deprecated)]
9215 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9216 where
9217 D: serde::Deserializer<'de>,
9218 {
9219 const FIELDS: &[&str] = &[
9220 "state_table",
9221 "stateTable",
9222 "sort_column_index",
9223 "sortColumnIndex",
9224 ];
9225
9226 #[allow(clippy::enum_variant_names)]
9227 enum GeneratedField {
9228 StateTable,
9229 SortColumnIndex,
9230 }
9231 impl<'de> serde::Deserialize<'de> for GeneratedField {
9232 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9233 where
9234 D: serde::Deserializer<'de>,
9235 {
9236 struct GeneratedVisitor;
9237
9238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9239 type Value = GeneratedField;
9240
9241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9242 write!(formatter, "expected one of: {:?}", &FIELDS)
9243 }
9244
9245 #[allow(unused_variables)]
9246 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9247 where
9248 E: serde::de::Error,
9249 {
9250 match value {
9251 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9252 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
9253 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9254 }
9255 }
9256 }
9257 deserializer.deserialize_identifier(GeneratedVisitor)
9258 }
9259 }
9260 struct GeneratedVisitor;
9261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9262 type Value = SortNode;
9263
9264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9265 formatter.write_str("struct stream_plan.SortNode")
9266 }
9267
9268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
9269 where
9270 V: serde::de::MapAccess<'de>,
9271 {
9272 let mut state_table__ = None;
9273 let mut sort_column_index__ = None;
9274 while let Some(k) = map_.next_key()? {
9275 match k {
9276 GeneratedField::StateTable => {
9277 if state_table__.is_some() {
9278 return Err(serde::de::Error::duplicate_field("stateTable"));
9279 }
9280 state_table__ = map_.next_value()?;
9281 }
9282 GeneratedField::SortColumnIndex => {
9283 if sort_column_index__.is_some() {
9284 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
9285 }
9286 sort_column_index__ =
9287 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9288 ;
9289 }
9290 }
9291 }
9292 Ok(SortNode {
9293 state_table: state_table__,
9294 sort_column_index: sort_column_index__.unwrap_or_default(),
9295 })
9296 }
9297 }
9298 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
9299 }
9300}
9301impl serde::Serialize for SourceBackfillNode {
9302 #[allow(deprecated)]
9303 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9304 where
9305 S: serde::Serializer,
9306 {
9307 use serde::ser::SerializeStruct;
9308 let mut len = 0;
9309 if self.upstream_source_id != 0 {
9310 len += 1;
9311 }
9312 if self.row_id_index.is_some() {
9313 len += 1;
9314 }
9315 if !self.columns.is_empty() {
9316 len += 1;
9317 }
9318 if self.info.is_some() {
9319 len += 1;
9320 }
9321 if !self.source_name.is_empty() {
9322 len += 1;
9323 }
9324 if !self.with_properties.is_empty() {
9325 len += 1;
9326 }
9327 if self.rate_limit.is_some() {
9328 len += 1;
9329 }
9330 if self.state_table.is_some() {
9331 len += 1;
9332 }
9333 if !self.secret_refs.is_empty() {
9334 len += 1;
9335 }
9336 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
9337 if self.upstream_source_id != 0 {
9338 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
9339 }
9340 if let Some(v) = self.row_id_index.as_ref() {
9341 struct_ser.serialize_field("rowIdIndex", v)?;
9342 }
9343 if !self.columns.is_empty() {
9344 struct_ser.serialize_field("columns", &self.columns)?;
9345 }
9346 if let Some(v) = self.info.as_ref() {
9347 struct_ser.serialize_field("info", v)?;
9348 }
9349 if !self.source_name.is_empty() {
9350 struct_ser.serialize_field("sourceName", &self.source_name)?;
9351 }
9352 if !self.with_properties.is_empty() {
9353 struct_ser.serialize_field("withProperties", &self.with_properties)?;
9354 }
9355 if let Some(v) = self.rate_limit.as_ref() {
9356 struct_ser.serialize_field("rateLimit", v)?;
9357 }
9358 if let Some(v) = self.state_table.as_ref() {
9359 struct_ser.serialize_field("stateTable", v)?;
9360 }
9361 if !self.secret_refs.is_empty() {
9362 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9363 }
9364 struct_ser.end()
9365 }
9366}
9367impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9368 #[allow(deprecated)]
9369 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9370 where
9371 D: serde::Deserializer<'de>,
9372 {
9373 const FIELDS: &[&str] = &[
9374 "upstream_source_id",
9375 "upstreamSourceId",
9376 "row_id_index",
9377 "rowIdIndex",
9378 "columns",
9379 "info",
9380 "source_name",
9381 "sourceName",
9382 "with_properties",
9383 "withProperties",
9384 "rate_limit",
9385 "rateLimit",
9386 "state_table",
9387 "stateTable",
9388 "secret_refs",
9389 "secretRefs",
9390 ];
9391
9392 #[allow(clippy::enum_variant_names)]
9393 enum GeneratedField {
9394 UpstreamSourceId,
9395 RowIdIndex,
9396 Columns,
9397 Info,
9398 SourceName,
9399 WithProperties,
9400 RateLimit,
9401 StateTable,
9402 SecretRefs,
9403 }
9404 impl<'de> serde::Deserialize<'de> for GeneratedField {
9405 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9406 where
9407 D: serde::Deserializer<'de>,
9408 {
9409 struct GeneratedVisitor;
9410
9411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9412 type Value = GeneratedField;
9413
9414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9415 write!(formatter, "expected one of: {:?}", &FIELDS)
9416 }
9417
9418 #[allow(unused_variables)]
9419 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9420 where
9421 E: serde::de::Error,
9422 {
9423 match value {
9424 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9425 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9426 "columns" => Ok(GeneratedField::Columns),
9427 "info" => Ok(GeneratedField::Info),
9428 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9429 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9430 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9431 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9432 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9433 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9434 }
9435 }
9436 }
9437 deserializer.deserialize_identifier(GeneratedVisitor)
9438 }
9439 }
9440 struct GeneratedVisitor;
9441 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9442 type Value = SourceBackfillNode;
9443
9444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9445 formatter.write_str("struct stream_plan.SourceBackfillNode")
9446 }
9447
9448 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9449 where
9450 V: serde::de::MapAccess<'de>,
9451 {
9452 let mut upstream_source_id__ = None;
9453 let mut row_id_index__ = None;
9454 let mut columns__ = None;
9455 let mut info__ = None;
9456 let mut source_name__ = None;
9457 let mut with_properties__ = None;
9458 let mut rate_limit__ = None;
9459 let mut state_table__ = None;
9460 let mut secret_refs__ = None;
9461 while let Some(k) = map_.next_key()? {
9462 match k {
9463 GeneratedField::UpstreamSourceId => {
9464 if upstream_source_id__.is_some() {
9465 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9466 }
9467 upstream_source_id__ =
9468 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9469 ;
9470 }
9471 GeneratedField::RowIdIndex => {
9472 if row_id_index__.is_some() {
9473 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9474 }
9475 row_id_index__ =
9476 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9477 ;
9478 }
9479 GeneratedField::Columns => {
9480 if columns__.is_some() {
9481 return Err(serde::de::Error::duplicate_field("columns"));
9482 }
9483 columns__ = Some(map_.next_value()?);
9484 }
9485 GeneratedField::Info => {
9486 if info__.is_some() {
9487 return Err(serde::de::Error::duplicate_field("info"));
9488 }
9489 info__ = map_.next_value()?;
9490 }
9491 GeneratedField::SourceName => {
9492 if source_name__.is_some() {
9493 return Err(serde::de::Error::duplicate_field("sourceName"));
9494 }
9495 source_name__ = Some(map_.next_value()?);
9496 }
9497 GeneratedField::WithProperties => {
9498 if with_properties__.is_some() {
9499 return Err(serde::de::Error::duplicate_field("withProperties"));
9500 }
9501 with_properties__ = Some(
9502 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9503 );
9504 }
9505 GeneratedField::RateLimit => {
9506 if rate_limit__.is_some() {
9507 return Err(serde::de::Error::duplicate_field("rateLimit"));
9508 }
9509 rate_limit__ =
9510 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9511 ;
9512 }
9513 GeneratedField::StateTable => {
9514 if state_table__.is_some() {
9515 return Err(serde::de::Error::duplicate_field("stateTable"));
9516 }
9517 state_table__ = map_.next_value()?;
9518 }
9519 GeneratedField::SecretRefs => {
9520 if secret_refs__.is_some() {
9521 return Err(serde::de::Error::duplicate_field("secretRefs"));
9522 }
9523 secret_refs__ = Some(
9524 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9525 );
9526 }
9527 }
9528 }
9529 Ok(SourceBackfillNode {
9530 upstream_source_id: upstream_source_id__.unwrap_or_default(),
9531 row_id_index: row_id_index__,
9532 columns: columns__.unwrap_or_default(),
9533 info: info__,
9534 source_name: source_name__.unwrap_or_default(),
9535 with_properties: with_properties__.unwrap_or_default(),
9536 rate_limit: rate_limit__,
9537 state_table: state_table__,
9538 secret_refs: secret_refs__.unwrap_or_default(),
9539 })
9540 }
9541 }
9542 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9543 }
9544}
9545impl serde::Serialize for SourceChangeSplitMutation {
9546 #[allow(deprecated)]
9547 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9548 where
9549 S: serde::Serializer,
9550 {
9551 use serde::ser::SerializeStruct;
9552 let mut len = 0;
9553 if !self.actor_splits.is_empty() {
9554 len += 1;
9555 }
9556 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9557 if !self.actor_splits.is_empty() {
9558 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9559 }
9560 struct_ser.end()
9561 }
9562}
9563impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9564 #[allow(deprecated)]
9565 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9566 where
9567 D: serde::Deserializer<'de>,
9568 {
9569 const FIELDS: &[&str] = &[
9570 "actor_splits",
9571 "actorSplits",
9572 ];
9573
9574 #[allow(clippy::enum_variant_names)]
9575 enum GeneratedField {
9576 ActorSplits,
9577 }
9578 impl<'de> serde::Deserialize<'de> for GeneratedField {
9579 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9580 where
9581 D: serde::Deserializer<'de>,
9582 {
9583 struct GeneratedVisitor;
9584
9585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9586 type Value = GeneratedField;
9587
9588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9589 write!(formatter, "expected one of: {:?}", &FIELDS)
9590 }
9591
9592 #[allow(unused_variables)]
9593 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9594 where
9595 E: serde::de::Error,
9596 {
9597 match value {
9598 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9599 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9600 }
9601 }
9602 }
9603 deserializer.deserialize_identifier(GeneratedVisitor)
9604 }
9605 }
9606 struct GeneratedVisitor;
9607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9608 type Value = SourceChangeSplitMutation;
9609
9610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9611 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9612 }
9613
9614 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9615 where
9616 V: serde::de::MapAccess<'de>,
9617 {
9618 let mut actor_splits__ = None;
9619 while let Some(k) = map_.next_key()? {
9620 match k {
9621 GeneratedField::ActorSplits => {
9622 if actor_splits__.is_some() {
9623 return Err(serde::de::Error::duplicate_field("actorSplits"));
9624 }
9625 actor_splits__ = Some(
9626 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9627 .into_iter().map(|(k,v)| (k.0, v)).collect()
9628 );
9629 }
9630 }
9631 }
9632 Ok(SourceChangeSplitMutation {
9633 actor_splits: actor_splits__.unwrap_or_default(),
9634 })
9635 }
9636 }
9637 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9638 }
9639}
9640impl serde::Serialize for SourceNode {
9641 #[allow(deprecated)]
9642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9643 where
9644 S: serde::Serializer,
9645 {
9646 use serde::ser::SerializeStruct;
9647 let mut len = 0;
9648 if self.source_inner.is_some() {
9649 len += 1;
9650 }
9651 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9652 if let Some(v) = self.source_inner.as_ref() {
9653 struct_ser.serialize_field("sourceInner", v)?;
9654 }
9655 struct_ser.end()
9656 }
9657}
9658impl<'de> serde::Deserialize<'de> for SourceNode {
9659 #[allow(deprecated)]
9660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9661 where
9662 D: serde::Deserializer<'de>,
9663 {
9664 const FIELDS: &[&str] = &[
9665 "source_inner",
9666 "sourceInner",
9667 ];
9668
9669 #[allow(clippy::enum_variant_names)]
9670 enum GeneratedField {
9671 SourceInner,
9672 }
9673 impl<'de> serde::Deserialize<'de> for GeneratedField {
9674 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9675 where
9676 D: serde::Deserializer<'de>,
9677 {
9678 struct GeneratedVisitor;
9679
9680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9681 type Value = GeneratedField;
9682
9683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9684 write!(formatter, "expected one of: {:?}", &FIELDS)
9685 }
9686
9687 #[allow(unused_variables)]
9688 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9689 where
9690 E: serde::de::Error,
9691 {
9692 match value {
9693 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9695 }
9696 }
9697 }
9698 deserializer.deserialize_identifier(GeneratedVisitor)
9699 }
9700 }
9701 struct GeneratedVisitor;
9702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9703 type Value = SourceNode;
9704
9705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9706 formatter.write_str("struct stream_plan.SourceNode")
9707 }
9708
9709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9710 where
9711 V: serde::de::MapAccess<'de>,
9712 {
9713 let mut source_inner__ = None;
9714 while let Some(k) = map_.next_key()? {
9715 match k {
9716 GeneratedField::SourceInner => {
9717 if source_inner__.is_some() {
9718 return Err(serde::de::Error::duplicate_field("sourceInner"));
9719 }
9720 source_inner__ = map_.next_value()?;
9721 }
9722 }
9723 }
9724 Ok(SourceNode {
9725 source_inner: source_inner__,
9726 })
9727 }
9728 }
9729 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
9730 }
9731}
9732impl serde::Serialize for StartFragmentBackfillMutation {
9733 #[allow(deprecated)]
9734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9735 where
9736 S: serde::Serializer,
9737 {
9738 use serde::ser::SerializeStruct;
9739 let mut len = 0;
9740 if !self.fragment_ids.is_empty() {
9741 len += 1;
9742 }
9743 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
9744 if !self.fragment_ids.is_empty() {
9745 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
9746 }
9747 struct_ser.end()
9748 }
9749}
9750impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
9751 #[allow(deprecated)]
9752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9753 where
9754 D: serde::Deserializer<'de>,
9755 {
9756 const FIELDS: &[&str] = &[
9757 "fragment_ids",
9758 "fragmentIds",
9759 ];
9760
9761 #[allow(clippy::enum_variant_names)]
9762 enum GeneratedField {
9763 FragmentIds,
9764 }
9765 impl<'de> serde::Deserialize<'de> for GeneratedField {
9766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9767 where
9768 D: serde::Deserializer<'de>,
9769 {
9770 struct GeneratedVisitor;
9771
9772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9773 type Value = GeneratedField;
9774
9775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9776 write!(formatter, "expected one of: {:?}", &FIELDS)
9777 }
9778
9779 #[allow(unused_variables)]
9780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9781 where
9782 E: serde::de::Error,
9783 {
9784 match value {
9785 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
9786 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9787 }
9788 }
9789 }
9790 deserializer.deserialize_identifier(GeneratedVisitor)
9791 }
9792 }
9793 struct GeneratedVisitor;
9794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9795 type Value = StartFragmentBackfillMutation;
9796
9797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9798 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
9799 }
9800
9801 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
9802 where
9803 V: serde::de::MapAccess<'de>,
9804 {
9805 let mut fragment_ids__ = None;
9806 while let Some(k) = map_.next_key()? {
9807 match k {
9808 GeneratedField::FragmentIds => {
9809 if fragment_ids__.is_some() {
9810 return Err(serde::de::Error::duplicate_field("fragmentIds"));
9811 }
9812 fragment_ids__ =
9813 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9814 .into_iter().map(|x| x.0).collect())
9815 ;
9816 }
9817 }
9818 }
9819 Ok(StartFragmentBackfillMutation {
9820 fragment_ids: fragment_ids__.unwrap_or_default(),
9821 })
9822 }
9823 }
9824 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
9825 }
9826}
9827impl serde::Serialize for StopMutation {
9828 #[allow(deprecated)]
9829 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9830 where
9831 S: serde::Serializer,
9832 {
9833 use serde::ser::SerializeStruct;
9834 let mut len = 0;
9835 if !self.actors.is_empty() {
9836 len += 1;
9837 }
9838 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
9839 if !self.actors.is_empty() {
9840 struct_ser.serialize_field("actors", &self.actors)?;
9841 }
9842 struct_ser.end()
9843 }
9844}
9845impl<'de> serde::Deserialize<'de> for StopMutation {
9846 #[allow(deprecated)]
9847 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9848 where
9849 D: serde::Deserializer<'de>,
9850 {
9851 const FIELDS: &[&str] = &[
9852 "actors",
9853 ];
9854
9855 #[allow(clippy::enum_variant_names)]
9856 enum GeneratedField {
9857 Actors,
9858 }
9859 impl<'de> serde::Deserialize<'de> for GeneratedField {
9860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9861 where
9862 D: serde::Deserializer<'de>,
9863 {
9864 struct GeneratedVisitor;
9865
9866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9867 type Value = GeneratedField;
9868
9869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9870 write!(formatter, "expected one of: {:?}", &FIELDS)
9871 }
9872
9873 #[allow(unused_variables)]
9874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9875 where
9876 E: serde::de::Error,
9877 {
9878 match value {
9879 "actors" => Ok(GeneratedField::Actors),
9880 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9881 }
9882 }
9883 }
9884 deserializer.deserialize_identifier(GeneratedVisitor)
9885 }
9886 }
9887 struct GeneratedVisitor;
9888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9889 type Value = StopMutation;
9890
9891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9892 formatter.write_str("struct stream_plan.StopMutation")
9893 }
9894
9895 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
9896 where
9897 V: serde::de::MapAccess<'de>,
9898 {
9899 let mut actors__ = None;
9900 while let Some(k) = map_.next_key()? {
9901 match k {
9902 GeneratedField::Actors => {
9903 if actors__.is_some() {
9904 return Err(serde::de::Error::duplicate_field("actors"));
9905 }
9906 actors__ =
9907 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9908 .into_iter().map(|x| x.0).collect())
9909 ;
9910 }
9911 }
9912 }
9913 Ok(StopMutation {
9914 actors: actors__.unwrap_or_default(),
9915 })
9916 }
9917 }
9918 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
9919 }
9920}
9921impl serde::Serialize for StreamActor {
9922 #[allow(deprecated)]
9923 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9924 where
9925 S: serde::Serializer,
9926 {
9927 use serde::ser::SerializeStruct;
9928 let mut len = 0;
9929 if self.actor_id != 0 {
9930 len += 1;
9931 }
9932 if self.fragment_id != 0 {
9933 len += 1;
9934 }
9935 if !self.dispatcher.is_empty() {
9936 len += 1;
9937 }
9938 if self.vnode_bitmap.is_some() {
9939 len += 1;
9940 }
9941 if !self.mview_definition.is_empty() {
9942 len += 1;
9943 }
9944 if self.expr_context.is_some() {
9945 len += 1;
9946 }
9947 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
9948 if self.actor_id != 0 {
9949 struct_ser.serialize_field("actorId", &self.actor_id)?;
9950 }
9951 if self.fragment_id != 0 {
9952 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9953 }
9954 if !self.dispatcher.is_empty() {
9955 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
9956 }
9957 if let Some(v) = self.vnode_bitmap.as_ref() {
9958 struct_ser.serialize_field("vnodeBitmap", v)?;
9959 }
9960 if !self.mview_definition.is_empty() {
9961 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
9962 }
9963 if let Some(v) = self.expr_context.as_ref() {
9964 struct_ser.serialize_field("exprContext", v)?;
9965 }
9966 struct_ser.end()
9967 }
9968}
9969impl<'de> serde::Deserialize<'de> for StreamActor {
9970 #[allow(deprecated)]
9971 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9972 where
9973 D: serde::Deserializer<'de>,
9974 {
9975 const FIELDS: &[&str] = &[
9976 "actor_id",
9977 "actorId",
9978 "fragment_id",
9979 "fragmentId",
9980 "dispatcher",
9981 "vnode_bitmap",
9982 "vnodeBitmap",
9983 "mview_definition",
9984 "mviewDefinition",
9985 "expr_context",
9986 "exprContext",
9987 ];
9988
9989 #[allow(clippy::enum_variant_names)]
9990 enum GeneratedField {
9991 ActorId,
9992 FragmentId,
9993 Dispatcher,
9994 VnodeBitmap,
9995 MviewDefinition,
9996 ExprContext,
9997 }
9998 impl<'de> serde::Deserialize<'de> for GeneratedField {
9999 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10000 where
10001 D: serde::Deserializer<'de>,
10002 {
10003 struct GeneratedVisitor;
10004
10005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10006 type Value = GeneratedField;
10007
10008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10009 write!(formatter, "expected one of: {:?}", &FIELDS)
10010 }
10011
10012 #[allow(unused_variables)]
10013 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10014 where
10015 E: serde::de::Error,
10016 {
10017 match value {
10018 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10019 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10020 "dispatcher" => Ok(GeneratedField::Dispatcher),
10021 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
10022 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
10023 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
10024 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10025 }
10026 }
10027 }
10028 deserializer.deserialize_identifier(GeneratedVisitor)
10029 }
10030 }
10031 struct GeneratedVisitor;
10032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10033 type Value = StreamActor;
10034
10035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10036 formatter.write_str("struct stream_plan.StreamActor")
10037 }
10038
10039 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
10040 where
10041 V: serde::de::MapAccess<'de>,
10042 {
10043 let mut actor_id__ = None;
10044 let mut fragment_id__ = None;
10045 let mut dispatcher__ = None;
10046 let mut vnode_bitmap__ = None;
10047 let mut mview_definition__ = None;
10048 let mut expr_context__ = None;
10049 while let Some(k) = map_.next_key()? {
10050 match k {
10051 GeneratedField::ActorId => {
10052 if actor_id__.is_some() {
10053 return Err(serde::de::Error::duplicate_field("actorId"));
10054 }
10055 actor_id__ =
10056 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10057 ;
10058 }
10059 GeneratedField::FragmentId => {
10060 if fragment_id__.is_some() {
10061 return Err(serde::de::Error::duplicate_field("fragmentId"));
10062 }
10063 fragment_id__ =
10064 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10065 ;
10066 }
10067 GeneratedField::Dispatcher => {
10068 if dispatcher__.is_some() {
10069 return Err(serde::de::Error::duplicate_field("dispatcher"));
10070 }
10071 dispatcher__ = Some(map_.next_value()?);
10072 }
10073 GeneratedField::VnodeBitmap => {
10074 if vnode_bitmap__.is_some() {
10075 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
10076 }
10077 vnode_bitmap__ = map_.next_value()?;
10078 }
10079 GeneratedField::MviewDefinition => {
10080 if mview_definition__.is_some() {
10081 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
10082 }
10083 mview_definition__ = Some(map_.next_value()?);
10084 }
10085 GeneratedField::ExprContext => {
10086 if expr_context__.is_some() {
10087 return Err(serde::de::Error::duplicate_field("exprContext"));
10088 }
10089 expr_context__ = map_.next_value()?;
10090 }
10091 }
10092 }
10093 Ok(StreamActor {
10094 actor_id: actor_id__.unwrap_or_default(),
10095 fragment_id: fragment_id__.unwrap_or_default(),
10096 dispatcher: dispatcher__.unwrap_or_default(),
10097 vnode_bitmap: vnode_bitmap__,
10098 mview_definition: mview_definition__.unwrap_or_default(),
10099 expr_context: expr_context__,
10100 })
10101 }
10102 }
10103 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
10104 }
10105}
10106impl serde::Serialize for StreamCdcScanNode {
10107 #[allow(deprecated)]
10108 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10109 where
10110 S: serde::Serializer,
10111 {
10112 use serde::ser::SerializeStruct;
10113 let mut len = 0;
10114 if self.table_id != 0 {
10115 len += 1;
10116 }
10117 if !self.upstream_column_ids.is_empty() {
10118 len += 1;
10119 }
10120 if !self.output_indices.is_empty() {
10121 len += 1;
10122 }
10123 if self.state_table.is_some() {
10124 len += 1;
10125 }
10126 if self.cdc_table_desc.is_some() {
10127 len += 1;
10128 }
10129 if self.rate_limit.is_some() {
10130 len += 1;
10131 }
10132 if self.disable_backfill {
10133 len += 1;
10134 }
10135 if self.options.is_some() {
10136 len += 1;
10137 }
10138 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
10139 if self.table_id != 0 {
10140 struct_ser.serialize_field("tableId", &self.table_id)?;
10141 }
10142 if !self.upstream_column_ids.is_empty() {
10143 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
10144 }
10145 if !self.output_indices.is_empty() {
10146 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
10147 }
10148 if let Some(v) = self.state_table.as_ref() {
10149 struct_ser.serialize_field("stateTable", v)?;
10150 }
10151 if let Some(v) = self.cdc_table_desc.as_ref() {
10152 struct_ser.serialize_field("cdcTableDesc", v)?;
10153 }
10154 if let Some(v) = self.rate_limit.as_ref() {
10155 struct_ser.serialize_field("rateLimit", v)?;
10156 }
10157 if self.disable_backfill {
10158 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10159 }
10160 if let Some(v) = self.options.as_ref() {
10161 struct_ser.serialize_field("options", v)?;
10162 }
10163 struct_ser.end()
10164 }
10165}
10166impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
10167 #[allow(deprecated)]
10168 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10169 where
10170 D: serde::Deserializer<'de>,
10171 {
10172 const FIELDS: &[&str] = &[
10173 "table_id",
10174 "tableId",
10175 "upstream_column_ids",
10176 "upstreamColumnIds",
10177 "output_indices",
10178 "outputIndices",
10179 "state_table",
10180 "stateTable",
10181 "cdc_table_desc",
10182 "cdcTableDesc",
10183 "rate_limit",
10184 "rateLimit",
10185 "disable_backfill",
10186 "disableBackfill",
10187 "options",
10188 ];
10189
10190 #[allow(clippy::enum_variant_names)]
10191 enum GeneratedField {
10192 TableId,
10193 UpstreamColumnIds,
10194 OutputIndices,
10195 StateTable,
10196 CdcTableDesc,
10197 RateLimit,
10198 DisableBackfill,
10199 Options,
10200 }
10201 impl<'de> serde::Deserialize<'de> for GeneratedField {
10202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10203 where
10204 D: serde::Deserializer<'de>,
10205 {
10206 struct GeneratedVisitor;
10207
10208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10209 type Value = GeneratedField;
10210
10211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10212 write!(formatter, "expected one of: {:?}", &FIELDS)
10213 }
10214
10215 #[allow(unused_variables)]
10216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10217 where
10218 E: serde::de::Error,
10219 {
10220 match value {
10221 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10222 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
10223 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
10224 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10225 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
10226 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10227 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10228 "options" => Ok(GeneratedField::Options),
10229 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10230 }
10231 }
10232 }
10233 deserializer.deserialize_identifier(GeneratedVisitor)
10234 }
10235 }
10236 struct GeneratedVisitor;
10237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10238 type Value = StreamCdcScanNode;
10239
10240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10241 formatter.write_str("struct stream_plan.StreamCdcScanNode")
10242 }
10243
10244 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
10245 where
10246 V: serde::de::MapAccess<'de>,
10247 {
10248 let mut table_id__ = None;
10249 let mut upstream_column_ids__ = None;
10250 let mut output_indices__ = None;
10251 let mut state_table__ = None;
10252 let mut cdc_table_desc__ = None;
10253 let mut rate_limit__ = None;
10254 let mut disable_backfill__ = None;
10255 let mut options__ = None;
10256 while let Some(k) = map_.next_key()? {
10257 match k {
10258 GeneratedField::TableId => {
10259 if table_id__.is_some() {
10260 return Err(serde::de::Error::duplicate_field("tableId"));
10261 }
10262 table_id__ =
10263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10264 ;
10265 }
10266 GeneratedField::UpstreamColumnIds => {
10267 if upstream_column_ids__.is_some() {
10268 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
10269 }
10270 upstream_column_ids__ =
10271 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10272 .into_iter().map(|x| x.0).collect())
10273 ;
10274 }
10275 GeneratedField::OutputIndices => {
10276 if output_indices__.is_some() {
10277 return Err(serde::de::Error::duplicate_field("outputIndices"));
10278 }
10279 output_indices__ =
10280 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10281 .into_iter().map(|x| x.0).collect())
10282 ;
10283 }
10284 GeneratedField::StateTable => {
10285 if state_table__.is_some() {
10286 return Err(serde::de::Error::duplicate_field("stateTable"));
10287 }
10288 state_table__ = map_.next_value()?;
10289 }
10290 GeneratedField::CdcTableDesc => {
10291 if cdc_table_desc__.is_some() {
10292 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
10293 }
10294 cdc_table_desc__ = map_.next_value()?;
10295 }
10296 GeneratedField::RateLimit => {
10297 if rate_limit__.is_some() {
10298 return Err(serde::de::Error::duplicate_field("rateLimit"));
10299 }
10300 rate_limit__ =
10301 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10302 ;
10303 }
10304 GeneratedField::DisableBackfill => {
10305 if disable_backfill__.is_some() {
10306 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10307 }
10308 disable_backfill__ = Some(map_.next_value()?);
10309 }
10310 GeneratedField::Options => {
10311 if options__.is_some() {
10312 return Err(serde::de::Error::duplicate_field("options"));
10313 }
10314 options__ = map_.next_value()?;
10315 }
10316 }
10317 }
10318 Ok(StreamCdcScanNode {
10319 table_id: table_id__.unwrap_or_default(),
10320 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
10321 output_indices: output_indices__.unwrap_or_default(),
10322 state_table: state_table__,
10323 cdc_table_desc: cdc_table_desc__,
10324 rate_limit: rate_limit__,
10325 disable_backfill: disable_backfill__.unwrap_or_default(),
10326 options: options__,
10327 })
10328 }
10329 }
10330 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
10331 }
10332}
10333impl serde::Serialize for StreamCdcScanOptions {
10334 #[allow(deprecated)]
10335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10336 where
10337 S: serde::Serializer,
10338 {
10339 use serde::ser::SerializeStruct;
10340 let mut len = 0;
10341 if self.disable_backfill {
10342 len += 1;
10343 }
10344 if self.snapshot_barrier_interval != 0 {
10345 len += 1;
10346 }
10347 if self.snapshot_batch_size != 0 {
10348 len += 1;
10349 }
10350 if self.backfill_parallelism != 0 {
10351 len += 1;
10352 }
10353 if self.backfill_num_rows_per_split != 0 {
10354 len += 1;
10355 }
10356 if self.backfill_as_even_splits {
10357 len += 1;
10358 }
10359 if self.backfill_split_pk_column_index != 0 {
10360 len += 1;
10361 }
10362 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10363 if self.disable_backfill {
10364 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10365 }
10366 if self.snapshot_barrier_interval != 0 {
10367 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10368 }
10369 if self.snapshot_batch_size != 0 {
10370 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10371 }
10372 if self.backfill_parallelism != 0 {
10373 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
10374 }
10375 if self.backfill_num_rows_per_split != 0 {
10376 #[allow(clippy::needless_borrow)]
10377 #[allow(clippy::needless_borrows_for_generic_args)]
10378 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
10379 }
10380 if self.backfill_as_even_splits {
10381 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
10382 }
10383 if self.backfill_split_pk_column_index != 0 {
10384 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
10385 }
10386 struct_ser.end()
10387 }
10388}
10389impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10390 #[allow(deprecated)]
10391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10392 where
10393 D: serde::Deserializer<'de>,
10394 {
10395 const FIELDS: &[&str] = &[
10396 "disable_backfill",
10397 "disableBackfill",
10398 "snapshot_barrier_interval",
10399 "snapshotBarrierInterval",
10400 "snapshot_batch_size",
10401 "snapshotBatchSize",
10402 "backfill_parallelism",
10403 "backfillParallelism",
10404 "backfill_num_rows_per_split",
10405 "backfillNumRowsPerSplit",
10406 "backfill_as_even_splits",
10407 "backfillAsEvenSplits",
10408 "backfill_split_pk_column_index",
10409 "backfillSplitPkColumnIndex",
10410 ];
10411
10412 #[allow(clippy::enum_variant_names)]
10413 enum GeneratedField {
10414 DisableBackfill,
10415 SnapshotBarrierInterval,
10416 SnapshotBatchSize,
10417 BackfillParallelism,
10418 BackfillNumRowsPerSplit,
10419 BackfillAsEvenSplits,
10420 BackfillSplitPkColumnIndex,
10421 }
10422 impl<'de> serde::Deserialize<'de> for GeneratedField {
10423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10424 where
10425 D: serde::Deserializer<'de>,
10426 {
10427 struct GeneratedVisitor;
10428
10429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10430 type Value = GeneratedField;
10431
10432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10433 write!(formatter, "expected one of: {:?}", &FIELDS)
10434 }
10435
10436 #[allow(unused_variables)]
10437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10438 where
10439 E: serde::de::Error,
10440 {
10441 match value {
10442 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10443 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10444 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10445 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
10446 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
10447 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
10448 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
10449 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10450 }
10451 }
10452 }
10453 deserializer.deserialize_identifier(GeneratedVisitor)
10454 }
10455 }
10456 struct GeneratedVisitor;
10457 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10458 type Value = StreamCdcScanOptions;
10459
10460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10461 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10462 }
10463
10464 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10465 where
10466 V: serde::de::MapAccess<'de>,
10467 {
10468 let mut disable_backfill__ = None;
10469 let mut snapshot_barrier_interval__ = None;
10470 let mut snapshot_batch_size__ = None;
10471 let mut backfill_parallelism__ = None;
10472 let mut backfill_num_rows_per_split__ = None;
10473 let mut backfill_as_even_splits__ = None;
10474 let mut backfill_split_pk_column_index__ = None;
10475 while let Some(k) = map_.next_key()? {
10476 match k {
10477 GeneratedField::DisableBackfill => {
10478 if disable_backfill__.is_some() {
10479 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10480 }
10481 disable_backfill__ = Some(map_.next_value()?);
10482 }
10483 GeneratedField::SnapshotBarrierInterval => {
10484 if snapshot_barrier_interval__.is_some() {
10485 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10486 }
10487 snapshot_barrier_interval__ =
10488 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10489 ;
10490 }
10491 GeneratedField::SnapshotBatchSize => {
10492 if snapshot_batch_size__.is_some() {
10493 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10494 }
10495 snapshot_batch_size__ =
10496 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10497 ;
10498 }
10499 GeneratedField::BackfillParallelism => {
10500 if backfill_parallelism__.is_some() {
10501 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
10502 }
10503 backfill_parallelism__ =
10504 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10505 ;
10506 }
10507 GeneratedField::BackfillNumRowsPerSplit => {
10508 if backfill_num_rows_per_split__.is_some() {
10509 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
10510 }
10511 backfill_num_rows_per_split__ =
10512 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10513 ;
10514 }
10515 GeneratedField::BackfillAsEvenSplits => {
10516 if backfill_as_even_splits__.is_some() {
10517 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
10518 }
10519 backfill_as_even_splits__ = Some(map_.next_value()?);
10520 }
10521 GeneratedField::BackfillSplitPkColumnIndex => {
10522 if backfill_split_pk_column_index__.is_some() {
10523 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
10524 }
10525 backfill_split_pk_column_index__ =
10526 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10527 ;
10528 }
10529 }
10530 }
10531 Ok(StreamCdcScanOptions {
10532 disable_backfill: disable_backfill__.unwrap_or_default(),
10533 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10534 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10535 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
10536 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
10537 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
10538 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
10539 })
10540 }
10541 }
10542 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10543 }
10544}
10545impl serde::Serialize for StreamContext {
10546 #[allow(deprecated)]
10547 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10548 where
10549 S: serde::Serializer,
10550 {
10551 use serde::ser::SerializeStruct;
10552 let mut len = 0;
10553 if !self.timezone.is_empty() {
10554 len += 1;
10555 }
10556 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10557 if !self.timezone.is_empty() {
10558 struct_ser.serialize_field("timezone", &self.timezone)?;
10559 }
10560 struct_ser.end()
10561 }
10562}
10563impl<'de> serde::Deserialize<'de> for StreamContext {
10564 #[allow(deprecated)]
10565 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10566 where
10567 D: serde::Deserializer<'de>,
10568 {
10569 const FIELDS: &[&str] = &[
10570 "timezone",
10571 ];
10572
10573 #[allow(clippy::enum_variant_names)]
10574 enum GeneratedField {
10575 Timezone,
10576 }
10577 impl<'de> serde::Deserialize<'de> for GeneratedField {
10578 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10579 where
10580 D: serde::Deserializer<'de>,
10581 {
10582 struct GeneratedVisitor;
10583
10584 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10585 type Value = GeneratedField;
10586
10587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10588 write!(formatter, "expected one of: {:?}", &FIELDS)
10589 }
10590
10591 #[allow(unused_variables)]
10592 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10593 where
10594 E: serde::de::Error,
10595 {
10596 match value {
10597 "timezone" => Ok(GeneratedField::Timezone),
10598 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10599 }
10600 }
10601 }
10602 deserializer.deserialize_identifier(GeneratedVisitor)
10603 }
10604 }
10605 struct GeneratedVisitor;
10606 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10607 type Value = StreamContext;
10608
10609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10610 formatter.write_str("struct stream_plan.StreamContext")
10611 }
10612
10613 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10614 where
10615 V: serde::de::MapAccess<'de>,
10616 {
10617 let mut timezone__ = None;
10618 while let Some(k) = map_.next_key()? {
10619 match k {
10620 GeneratedField::Timezone => {
10621 if timezone__.is_some() {
10622 return Err(serde::de::Error::duplicate_field("timezone"));
10623 }
10624 timezone__ = Some(map_.next_value()?);
10625 }
10626 }
10627 }
10628 Ok(StreamContext {
10629 timezone: timezone__.unwrap_or_default(),
10630 })
10631 }
10632 }
10633 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10634 }
10635}
10636impl serde::Serialize for StreamFragmentGraph {
10637 #[allow(deprecated)]
10638 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10639 where
10640 S: serde::Serializer,
10641 {
10642 use serde::ser::SerializeStruct;
10643 let mut len = 0;
10644 if !self.fragments.is_empty() {
10645 len += 1;
10646 }
10647 if !self.edges.is_empty() {
10648 len += 1;
10649 }
10650 if !self.dependent_table_ids.is_empty() {
10651 len += 1;
10652 }
10653 if self.table_ids_cnt != 0 {
10654 len += 1;
10655 }
10656 if self.ctx.is_some() {
10657 len += 1;
10658 }
10659 if self.parallelism.is_some() {
10660 len += 1;
10661 }
10662 if self.max_parallelism != 0 {
10663 len += 1;
10664 }
10665 if self.backfill_order.is_some() {
10666 len += 1;
10667 }
10668 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10669 if !self.fragments.is_empty() {
10670 struct_ser.serialize_field("fragments", &self.fragments)?;
10671 }
10672 if !self.edges.is_empty() {
10673 struct_ser.serialize_field("edges", &self.edges)?;
10674 }
10675 if !self.dependent_table_ids.is_empty() {
10676 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10677 }
10678 if self.table_ids_cnt != 0 {
10679 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10680 }
10681 if let Some(v) = self.ctx.as_ref() {
10682 struct_ser.serialize_field("ctx", v)?;
10683 }
10684 if let Some(v) = self.parallelism.as_ref() {
10685 struct_ser.serialize_field("parallelism", v)?;
10686 }
10687 if self.max_parallelism != 0 {
10688 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10689 }
10690 if let Some(v) = self.backfill_order.as_ref() {
10691 struct_ser.serialize_field("backfillOrder", v)?;
10692 }
10693 struct_ser.end()
10694 }
10695}
10696impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
10697 #[allow(deprecated)]
10698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10699 where
10700 D: serde::Deserializer<'de>,
10701 {
10702 const FIELDS: &[&str] = &[
10703 "fragments",
10704 "edges",
10705 "dependent_table_ids",
10706 "dependentTableIds",
10707 "table_ids_cnt",
10708 "tableIdsCnt",
10709 "ctx",
10710 "parallelism",
10711 "max_parallelism",
10712 "maxParallelism",
10713 "backfill_order",
10714 "backfillOrder",
10715 ];
10716
10717 #[allow(clippy::enum_variant_names)]
10718 enum GeneratedField {
10719 Fragments,
10720 Edges,
10721 DependentTableIds,
10722 TableIdsCnt,
10723 Ctx,
10724 Parallelism,
10725 MaxParallelism,
10726 BackfillOrder,
10727 }
10728 impl<'de> serde::Deserialize<'de> for GeneratedField {
10729 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10730 where
10731 D: serde::Deserializer<'de>,
10732 {
10733 struct GeneratedVisitor;
10734
10735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10736 type Value = GeneratedField;
10737
10738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10739 write!(formatter, "expected one of: {:?}", &FIELDS)
10740 }
10741
10742 #[allow(unused_variables)]
10743 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10744 where
10745 E: serde::de::Error,
10746 {
10747 match value {
10748 "fragments" => Ok(GeneratedField::Fragments),
10749 "edges" => Ok(GeneratedField::Edges),
10750 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
10751 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10752 "ctx" => Ok(GeneratedField::Ctx),
10753 "parallelism" => Ok(GeneratedField::Parallelism),
10754 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10755 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
10756 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10757 }
10758 }
10759 }
10760 deserializer.deserialize_identifier(GeneratedVisitor)
10761 }
10762 }
10763 struct GeneratedVisitor;
10764 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10765 type Value = StreamFragmentGraph;
10766
10767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10768 formatter.write_str("struct stream_plan.StreamFragmentGraph")
10769 }
10770
10771 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
10772 where
10773 V: serde::de::MapAccess<'de>,
10774 {
10775 let mut fragments__ = None;
10776 let mut edges__ = None;
10777 let mut dependent_table_ids__ = None;
10778 let mut table_ids_cnt__ = None;
10779 let mut ctx__ = None;
10780 let mut parallelism__ = None;
10781 let mut max_parallelism__ = None;
10782 let mut backfill_order__ = None;
10783 while let Some(k) = map_.next_key()? {
10784 match k {
10785 GeneratedField::Fragments => {
10786 if fragments__.is_some() {
10787 return Err(serde::de::Error::duplicate_field("fragments"));
10788 }
10789 fragments__ = Some(
10790 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10791 .into_iter().map(|(k,v)| (k.0, v)).collect()
10792 );
10793 }
10794 GeneratedField::Edges => {
10795 if edges__.is_some() {
10796 return Err(serde::de::Error::duplicate_field("edges"));
10797 }
10798 edges__ = Some(map_.next_value()?);
10799 }
10800 GeneratedField::DependentTableIds => {
10801 if dependent_table_ids__.is_some() {
10802 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
10803 }
10804 dependent_table_ids__ =
10805 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10806 .into_iter().map(|x| x.0).collect())
10807 ;
10808 }
10809 GeneratedField::TableIdsCnt => {
10810 if table_ids_cnt__.is_some() {
10811 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10812 }
10813 table_ids_cnt__ =
10814 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10815 ;
10816 }
10817 GeneratedField::Ctx => {
10818 if ctx__.is_some() {
10819 return Err(serde::de::Error::duplicate_field("ctx"));
10820 }
10821 ctx__ = map_.next_value()?;
10822 }
10823 GeneratedField::Parallelism => {
10824 if parallelism__.is_some() {
10825 return Err(serde::de::Error::duplicate_field("parallelism"));
10826 }
10827 parallelism__ = map_.next_value()?;
10828 }
10829 GeneratedField::MaxParallelism => {
10830 if max_parallelism__.is_some() {
10831 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10832 }
10833 max_parallelism__ =
10834 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10835 ;
10836 }
10837 GeneratedField::BackfillOrder => {
10838 if backfill_order__.is_some() {
10839 return Err(serde::de::Error::duplicate_field("backfillOrder"));
10840 }
10841 backfill_order__ = map_.next_value()?;
10842 }
10843 }
10844 }
10845 Ok(StreamFragmentGraph {
10846 fragments: fragments__.unwrap_or_default(),
10847 edges: edges__.unwrap_or_default(),
10848 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
10849 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10850 ctx: ctx__,
10851 parallelism: parallelism__,
10852 max_parallelism: max_parallelism__.unwrap_or_default(),
10853 backfill_order: backfill_order__,
10854 })
10855 }
10856 }
10857 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
10858 }
10859}
10860impl serde::Serialize for stream_fragment_graph::Parallelism {
10861 #[allow(deprecated)]
10862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10863 where
10864 S: serde::Serializer,
10865 {
10866 use serde::ser::SerializeStruct;
10867 let mut len = 0;
10868 if self.parallelism != 0 {
10869 len += 1;
10870 }
10871 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
10872 if self.parallelism != 0 {
10873 #[allow(clippy::needless_borrow)]
10874 #[allow(clippy::needless_borrows_for_generic_args)]
10875 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
10876 }
10877 struct_ser.end()
10878 }
10879}
10880impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
10881 #[allow(deprecated)]
10882 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10883 where
10884 D: serde::Deserializer<'de>,
10885 {
10886 const FIELDS: &[&str] = &[
10887 "parallelism",
10888 ];
10889
10890 #[allow(clippy::enum_variant_names)]
10891 enum GeneratedField {
10892 Parallelism,
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<'de> serde::de::Visitor<'de> 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 "parallelism" => Ok(GeneratedField::Parallelism),
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 = stream_fragment_graph::Parallelism;
10925
10926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10927 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
10928 }
10929
10930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
10931 where
10932 V: serde::de::MapAccess<'de>,
10933 {
10934 let mut parallelism__ = None;
10935 while let Some(k) = map_.next_key()? {
10936 match k {
10937 GeneratedField::Parallelism => {
10938 if parallelism__.is_some() {
10939 return Err(serde::de::Error::duplicate_field("parallelism"));
10940 }
10941 parallelism__ =
10942 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10943 ;
10944 }
10945 }
10946 }
10947 Ok(stream_fragment_graph::Parallelism {
10948 parallelism: parallelism__.unwrap_or_default(),
10949 })
10950 }
10951 }
10952 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
10953 }
10954}
10955impl serde::Serialize for stream_fragment_graph::StreamFragment {
10956 #[allow(deprecated)]
10957 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10958 where
10959 S: serde::Serializer,
10960 {
10961 use serde::ser::SerializeStruct;
10962 let mut len = 0;
10963 if self.fragment_id != 0 {
10964 len += 1;
10965 }
10966 if self.node.is_some() {
10967 len += 1;
10968 }
10969 if self.fragment_type_mask != 0 {
10970 len += 1;
10971 }
10972 if self.requires_singleton {
10973 len += 1;
10974 }
10975 if self.table_ids_cnt != 0 {
10976 len += 1;
10977 }
10978 if !self.upstream_table_ids.is_empty() {
10979 len += 1;
10980 }
10981 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
10982 if self.fragment_id != 0 {
10983 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10984 }
10985 if let Some(v) = self.node.as_ref() {
10986 struct_ser.serialize_field("node", v)?;
10987 }
10988 if self.fragment_type_mask != 0 {
10989 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10990 }
10991 if self.requires_singleton {
10992 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
10993 }
10994 if self.table_ids_cnt != 0 {
10995 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10996 }
10997 if !self.upstream_table_ids.is_empty() {
10998 struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
10999 }
11000 struct_ser.end()
11001 }
11002}
11003impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11004 #[allow(deprecated)]
11005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11006 where
11007 D: serde::Deserializer<'de>,
11008 {
11009 const FIELDS: &[&str] = &[
11010 "fragment_id",
11011 "fragmentId",
11012 "node",
11013 "fragment_type_mask",
11014 "fragmentTypeMask",
11015 "requires_singleton",
11016 "requiresSingleton",
11017 "table_ids_cnt",
11018 "tableIdsCnt",
11019 "upstream_table_ids",
11020 "upstreamTableIds",
11021 ];
11022
11023 #[allow(clippy::enum_variant_names)]
11024 enum GeneratedField {
11025 FragmentId,
11026 Node,
11027 FragmentTypeMask,
11028 RequiresSingleton,
11029 TableIdsCnt,
11030 UpstreamTableIds,
11031 }
11032 impl<'de> serde::Deserialize<'de> for GeneratedField {
11033 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11034 where
11035 D: serde::Deserializer<'de>,
11036 {
11037 struct GeneratedVisitor;
11038
11039 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11040 type Value = GeneratedField;
11041
11042 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11043 write!(formatter, "expected one of: {:?}", &FIELDS)
11044 }
11045
11046 #[allow(unused_variables)]
11047 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11048 where
11049 E: serde::de::Error,
11050 {
11051 match value {
11052 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11053 "node" => Ok(GeneratedField::Node),
11054 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11055 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
11056 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11057 "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
11058 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11059 }
11060 }
11061 }
11062 deserializer.deserialize_identifier(GeneratedVisitor)
11063 }
11064 }
11065 struct GeneratedVisitor;
11066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11067 type Value = stream_fragment_graph::StreamFragment;
11068
11069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11070 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
11071 }
11072
11073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
11074 where
11075 V: serde::de::MapAccess<'de>,
11076 {
11077 let mut fragment_id__ = None;
11078 let mut node__ = None;
11079 let mut fragment_type_mask__ = None;
11080 let mut requires_singleton__ = None;
11081 let mut table_ids_cnt__ = None;
11082 let mut upstream_table_ids__ = None;
11083 while let Some(k) = map_.next_key()? {
11084 match k {
11085 GeneratedField::FragmentId => {
11086 if fragment_id__.is_some() {
11087 return Err(serde::de::Error::duplicate_field("fragmentId"));
11088 }
11089 fragment_id__ =
11090 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11091 ;
11092 }
11093 GeneratedField::Node => {
11094 if node__.is_some() {
11095 return Err(serde::de::Error::duplicate_field("node"));
11096 }
11097 node__ = map_.next_value()?;
11098 }
11099 GeneratedField::FragmentTypeMask => {
11100 if fragment_type_mask__.is_some() {
11101 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11102 }
11103 fragment_type_mask__ =
11104 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11105 ;
11106 }
11107 GeneratedField::RequiresSingleton => {
11108 if requires_singleton__.is_some() {
11109 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
11110 }
11111 requires_singleton__ = Some(map_.next_value()?);
11112 }
11113 GeneratedField::TableIdsCnt => {
11114 if table_ids_cnt__.is_some() {
11115 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11116 }
11117 table_ids_cnt__ =
11118 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11119 ;
11120 }
11121 GeneratedField::UpstreamTableIds => {
11122 if upstream_table_ids__.is_some() {
11123 return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
11124 }
11125 upstream_table_ids__ =
11126 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11127 .into_iter().map(|x| x.0).collect())
11128 ;
11129 }
11130 }
11131 }
11132 Ok(stream_fragment_graph::StreamFragment {
11133 fragment_id: fragment_id__.unwrap_or_default(),
11134 node: node__,
11135 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11136 requires_singleton: requires_singleton__.unwrap_or_default(),
11137 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11138 upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
11139 })
11140 }
11141 }
11142 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
11143 }
11144}
11145impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
11146 #[allow(deprecated)]
11147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11148 where
11149 S: serde::Serializer,
11150 {
11151 use serde::ser::SerializeStruct;
11152 let mut len = 0;
11153 if self.dispatch_strategy.is_some() {
11154 len += 1;
11155 }
11156 if self.link_id != 0 {
11157 len += 1;
11158 }
11159 if self.upstream_id != 0 {
11160 len += 1;
11161 }
11162 if self.downstream_id != 0 {
11163 len += 1;
11164 }
11165 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
11166 if let Some(v) = self.dispatch_strategy.as_ref() {
11167 struct_ser.serialize_field("dispatchStrategy", v)?;
11168 }
11169 if self.link_id != 0 {
11170 #[allow(clippy::needless_borrow)]
11171 #[allow(clippy::needless_borrows_for_generic_args)]
11172 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
11173 }
11174 if self.upstream_id != 0 {
11175 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
11176 }
11177 if self.downstream_id != 0 {
11178 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
11179 }
11180 struct_ser.end()
11181 }
11182}
11183impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
11184 #[allow(deprecated)]
11185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11186 where
11187 D: serde::Deserializer<'de>,
11188 {
11189 const FIELDS: &[&str] = &[
11190 "dispatch_strategy",
11191 "dispatchStrategy",
11192 "link_id",
11193 "linkId",
11194 "upstream_id",
11195 "upstreamId",
11196 "downstream_id",
11197 "downstreamId",
11198 ];
11199
11200 #[allow(clippy::enum_variant_names)]
11201 enum GeneratedField {
11202 DispatchStrategy,
11203 LinkId,
11204 UpstreamId,
11205 DownstreamId,
11206 }
11207 impl<'de> serde::Deserialize<'de> for GeneratedField {
11208 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11209 where
11210 D: serde::Deserializer<'de>,
11211 {
11212 struct GeneratedVisitor;
11213
11214 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11215 type Value = GeneratedField;
11216
11217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11218 write!(formatter, "expected one of: {:?}", &FIELDS)
11219 }
11220
11221 #[allow(unused_variables)]
11222 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11223 where
11224 E: serde::de::Error,
11225 {
11226 match value {
11227 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
11228 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
11229 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
11230 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
11231 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11232 }
11233 }
11234 }
11235 deserializer.deserialize_identifier(GeneratedVisitor)
11236 }
11237 }
11238 struct GeneratedVisitor;
11239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11240 type Value = stream_fragment_graph::StreamFragmentEdge;
11241
11242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11243 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
11244 }
11245
11246 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
11247 where
11248 V: serde::de::MapAccess<'de>,
11249 {
11250 let mut dispatch_strategy__ = None;
11251 let mut link_id__ = None;
11252 let mut upstream_id__ = None;
11253 let mut downstream_id__ = None;
11254 while let Some(k) = map_.next_key()? {
11255 match k {
11256 GeneratedField::DispatchStrategy => {
11257 if dispatch_strategy__.is_some() {
11258 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
11259 }
11260 dispatch_strategy__ = map_.next_value()?;
11261 }
11262 GeneratedField::LinkId => {
11263 if link_id__.is_some() {
11264 return Err(serde::de::Error::duplicate_field("linkId"));
11265 }
11266 link_id__ =
11267 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11268 ;
11269 }
11270 GeneratedField::UpstreamId => {
11271 if upstream_id__.is_some() {
11272 return Err(serde::de::Error::duplicate_field("upstreamId"));
11273 }
11274 upstream_id__ =
11275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11276 ;
11277 }
11278 GeneratedField::DownstreamId => {
11279 if downstream_id__.is_some() {
11280 return Err(serde::de::Error::duplicate_field("downstreamId"));
11281 }
11282 downstream_id__ =
11283 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11284 ;
11285 }
11286 }
11287 }
11288 Ok(stream_fragment_graph::StreamFragmentEdge {
11289 dispatch_strategy: dispatch_strategy__,
11290 link_id: link_id__.unwrap_or_default(),
11291 upstream_id: upstream_id__.unwrap_or_default(),
11292 downstream_id: downstream_id__.unwrap_or_default(),
11293 })
11294 }
11295 }
11296 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
11297 }
11298}
11299impl serde::Serialize for StreamFsFetch {
11300 #[allow(deprecated)]
11301 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11302 where
11303 S: serde::Serializer,
11304 {
11305 use serde::ser::SerializeStruct;
11306 let mut len = 0;
11307 if self.source_id != 0 {
11308 len += 1;
11309 }
11310 if self.state_table.is_some() {
11311 len += 1;
11312 }
11313 if self.row_id_index.is_some() {
11314 len += 1;
11315 }
11316 if !self.columns.is_empty() {
11317 len += 1;
11318 }
11319 if !self.with_properties.is_empty() {
11320 len += 1;
11321 }
11322 if self.info.is_some() {
11323 len += 1;
11324 }
11325 if !self.source_name.is_empty() {
11326 len += 1;
11327 }
11328 if self.rate_limit.is_some() {
11329 len += 1;
11330 }
11331 if !self.secret_refs.is_empty() {
11332 len += 1;
11333 }
11334 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
11335 if self.source_id != 0 {
11336 struct_ser.serialize_field("sourceId", &self.source_id)?;
11337 }
11338 if let Some(v) = self.state_table.as_ref() {
11339 struct_ser.serialize_field("stateTable", v)?;
11340 }
11341 if let Some(v) = self.row_id_index.as_ref() {
11342 struct_ser.serialize_field("rowIdIndex", v)?;
11343 }
11344 if !self.columns.is_empty() {
11345 struct_ser.serialize_field("columns", &self.columns)?;
11346 }
11347 if !self.with_properties.is_empty() {
11348 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11349 }
11350 if let Some(v) = self.info.as_ref() {
11351 struct_ser.serialize_field("info", v)?;
11352 }
11353 if !self.source_name.is_empty() {
11354 struct_ser.serialize_field("sourceName", &self.source_name)?;
11355 }
11356 if let Some(v) = self.rate_limit.as_ref() {
11357 struct_ser.serialize_field("rateLimit", v)?;
11358 }
11359 if !self.secret_refs.is_empty() {
11360 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11361 }
11362 struct_ser.end()
11363 }
11364}
11365impl<'de> serde::Deserialize<'de> for StreamFsFetch {
11366 #[allow(deprecated)]
11367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11368 where
11369 D: serde::Deserializer<'de>,
11370 {
11371 const FIELDS: &[&str] = &[
11372 "source_id",
11373 "sourceId",
11374 "state_table",
11375 "stateTable",
11376 "row_id_index",
11377 "rowIdIndex",
11378 "columns",
11379 "with_properties",
11380 "withProperties",
11381 "info",
11382 "source_name",
11383 "sourceName",
11384 "rate_limit",
11385 "rateLimit",
11386 "secret_refs",
11387 "secretRefs",
11388 ];
11389
11390 #[allow(clippy::enum_variant_names)]
11391 enum GeneratedField {
11392 SourceId,
11393 StateTable,
11394 RowIdIndex,
11395 Columns,
11396 WithProperties,
11397 Info,
11398 SourceName,
11399 RateLimit,
11400 SecretRefs,
11401 }
11402 impl<'de> serde::Deserialize<'de> for GeneratedField {
11403 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11404 where
11405 D: serde::Deserializer<'de>,
11406 {
11407 struct GeneratedVisitor;
11408
11409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11410 type Value = GeneratedField;
11411
11412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11413 write!(formatter, "expected one of: {:?}", &FIELDS)
11414 }
11415
11416 #[allow(unused_variables)]
11417 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11418 where
11419 E: serde::de::Error,
11420 {
11421 match value {
11422 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11423 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11424 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11425 "columns" => Ok(GeneratedField::Columns),
11426 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11427 "info" => Ok(GeneratedField::Info),
11428 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11429 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11430 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11431 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11432 }
11433 }
11434 }
11435 deserializer.deserialize_identifier(GeneratedVisitor)
11436 }
11437 }
11438 struct GeneratedVisitor;
11439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11440 type Value = StreamFsFetch;
11441
11442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11443 formatter.write_str("struct stream_plan.StreamFsFetch")
11444 }
11445
11446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11447 where
11448 V: serde::de::MapAccess<'de>,
11449 {
11450 let mut source_id__ = None;
11451 let mut state_table__ = None;
11452 let mut row_id_index__ = None;
11453 let mut columns__ = None;
11454 let mut with_properties__ = None;
11455 let mut info__ = None;
11456 let mut source_name__ = None;
11457 let mut rate_limit__ = None;
11458 let mut secret_refs__ = None;
11459 while let Some(k) = map_.next_key()? {
11460 match k {
11461 GeneratedField::SourceId => {
11462 if source_id__.is_some() {
11463 return Err(serde::de::Error::duplicate_field("sourceId"));
11464 }
11465 source_id__ =
11466 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11467 ;
11468 }
11469 GeneratedField::StateTable => {
11470 if state_table__.is_some() {
11471 return Err(serde::de::Error::duplicate_field("stateTable"));
11472 }
11473 state_table__ = map_.next_value()?;
11474 }
11475 GeneratedField::RowIdIndex => {
11476 if row_id_index__.is_some() {
11477 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11478 }
11479 row_id_index__ =
11480 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11481 ;
11482 }
11483 GeneratedField::Columns => {
11484 if columns__.is_some() {
11485 return Err(serde::de::Error::duplicate_field("columns"));
11486 }
11487 columns__ = Some(map_.next_value()?);
11488 }
11489 GeneratedField::WithProperties => {
11490 if with_properties__.is_some() {
11491 return Err(serde::de::Error::duplicate_field("withProperties"));
11492 }
11493 with_properties__ = Some(
11494 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11495 );
11496 }
11497 GeneratedField::Info => {
11498 if info__.is_some() {
11499 return Err(serde::de::Error::duplicate_field("info"));
11500 }
11501 info__ = map_.next_value()?;
11502 }
11503 GeneratedField::SourceName => {
11504 if source_name__.is_some() {
11505 return Err(serde::de::Error::duplicate_field("sourceName"));
11506 }
11507 source_name__ = Some(map_.next_value()?);
11508 }
11509 GeneratedField::RateLimit => {
11510 if rate_limit__.is_some() {
11511 return Err(serde::de::Error::duplicate_field("rateLimit"));
11512 }
11513 rate_limit__ =
11514 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11515 ;
11516 }
11517 GeneratedField::SecretRefs => {
11518 if secret_refs__.is_some() {
11519 return Err(serde::de::Error::duplicate_field("secretRefs"));
11520 }
11521 secret_refs__ = Some(
11522 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11523 );
11524 }
11525 }
11526 }
11527 Ok(StreamFsFetch {
11528 source_id: source_id__.unwrap_or_default(),
11529 state_table: state_table__,
11530 row_id_index: row_id_index__,
11531 columns: columns__.unwrap_or_default(),
11532 with_properties: with_properties__.unwrap_or_default(),
11533 info: info__,
11534 source_name: source_name__.unwrap_or_default(),
11535 rate_limit: rate_limit__,
11536 secret_refs: secret_refs__.unwrap_or_default(),
11537 })
11538 }
11539 }
11540 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11541 }
11542}
11543impl serde::Serialize for StreamFsFetchNode {
11544 #[allow(deprecated)]
11545 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11546 where
11547 S: serde::Serializer,
11548 {
11549 use serde::ser::SerializeStruct;
11550 let mut len = 0;
11551 if self.node_inner.is_some() {
11552 len += 1;
11553 }
11554 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11555 if let Some(v) = self.node_inner.as_ref() {
11556 struct_ser.serialize_field("nodeInner", v)?;
11557 }
11558 struct_ser.end()
11559 }
11560}
11561impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11562 #[allow(deprecated)]
11563 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11564 where
11565 D: serde::Deserializer<'de>,
11566 {
11567 const FIELDS: &[&str] = &[
11568 "node_inner",
11569 "nodeInner",
11570 ];
11571
11572 #[allow(clippy::enum_variant_names)]
11573 enum GeneratedField {
11574 NodeInner,
11575 }
11576 impl<'de> serde::Deserialize<'de> for GeneratedField {
11577 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11578 where
11579 D: serde::Deserializer<'de>,
11580 {
11581 struct GeneratedVisitor;
11582
11583 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11584 type Value = GeneratedField;
11585
11586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11587 write!(formatter, "expected one of: {:?}", &FIELDS)
11588 }
11589
11590 #[allow(unused_variables)]
11591 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11592 where
11593 E: serde::de::Error,
11594 {
11595 match value {
11596 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11598 }
11599 }
11600 }
11601 deserializer.deserialize_identifier(GeneratedVisitor)
11602 }
11603 }
11604 struct GeneratedVisitor;
11605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11606 type Value = StreamFsFetchNode;
11607
11608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11609 formatter.write_str("struct stream_plan.StreamFsFetchNode")
11610 }
11611
11612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11613 where
11614 V: serde::de::MapAccess<'de>,
11615 {
11616 let mut node_inner__ = None;
11617 while let Some(k) = map_.next_key()? {
11618 match k {
11619 GeneratedField::NodeInner => {
11620 if node_inner__.is_some() {
11621 return Err(serde::de::Error::duplicate_field("nodeInner"));
11622 }
11623 node_inner__ = map_.next_value()?;
11624 }
11625 }
11626 }
11627 Ok(StreamFsFetchNode {
11628 node_inner: node_inner__,
11629 })
11630 }
11631 }
11632 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11633 }
11634}
11635impl serde::Serialize for StreamMessage {
11636 #[allow(deprecated)]
11637 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11638 where
11639 S: serde::Serializer,
11640 {
11641 use serde::ser::SerializeStruct;
11642 let mut len = 0;
11643 if self.stream_message.is_some() {
11644 len += 1;
11645 }
11646 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11647 if let Some(v) = self.stream_message.as_ref() {
11648 match v {
11649 stream_message::StreamMessage::StreamChunk(v) => {
11650 struct_ser.serialize_field("streamChunk", v)?;
11651 }
11652 stream_message::StreamMessage::Barrier(v) => {
11653 struct_ser.serialize_field("barrier", v)?;
11654 }
11655 stream_message::StreamMessage::Watermark(v) => {
11656 struct_ser.serialize_field("watermark", v)?;
11657 }
11658 }
11659 }
11660 struct_ser.end()
11661 }
11662}
11663impl<'de> serde::Deserialize<'de> for StreamMessage {
11664 #[allow(deprecated)]
11665 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11666 where
11667 D: serde::Deserializer<'de>,
11668 {
11669 const FIELDS: &[&str] = &[
11670 "stream_chunk",
11671 "streamChunk",
11672 "barrier",
11673 "watermark",
11674 ];
11675
11676 #[allow(clippy::enum_variant_names)]
11677 enum GeneratedField {
11678 StreamChunk,
11679 Barrier,
11680 Watermark,
11681 }
11682 impl<'de> serde::Deserialize<'de> for GeneratedField {
11683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11684 where
11685 D: serde::Deserializer<'de>,
11686 {
11687 struct GeneratedVisitor;
11688
11689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11690 type Value = GeneratedField;
11691
11692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11693 write!(formatter, "expected one of: {:?}", &FIELDS)
11694 }
11695
11696 #[allow(unused_variables)]
11697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11698 where
11699 E: serde::de::Error,
11700 {
11701 match value {
11702 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11703 "barrier" => Ok(GeneratedField::Barrier),
11704 "watermark" => Ok(GeneratedField::Watermark),
11705 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11706 }
11707 }
11708 }
11709 deserializer.deserialize_identifier(GeneratedVisitor)
11710 }
11711 }
11712 struct GeneratedVisitor;
11713 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11714 type Value = StreamMessage;
11715
11716 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11717 formatter.write_str("struct stream_plan.StreamMessage")
11718 }
11719
11720 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
11721 where
11722 V: serde::de::MapAccess<'de>,
11723 {
11724 let mut stream_message__ = None;
11725 while let Some(k) = map_.next_key()? {
11726 match k {
11727 GeneratedField::StreamChunk => {
11728 if stream_message__.is_some() {
11729 return Err(serde::de::Error::duplicate_field("streamChunk"));
11730 }
11731 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
11732;
11733 }
11734 GeneratedField::Barrier => {
11735 if stream_message__.is_some() {
11736 return Err(serde::de::Error::duplicate_field("barrier"));
11737 }
11738 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
11739;
11740 }
11741 GeneratedField::Watermark => {
11742 if stream_message__.is_some() {
11743 return Err(serde::de::Error::duplicate_field("watermark"));
11744 }
11745 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
11746;
11747 }
11748 }
11749 }
11750 Ok(StreamMessage {
11751 stream_message: stream_message__,
11752 })
11753 }
11754 }
11755 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
11756 }
11757}
11758impl serde::Serialize for StreamMessageBatch {
11759 #[allow(deprecated)]
11760 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11761 where
11762 S: serde::Serializer,
11763 {
11764 use serde::ser::SerializeStruct;
11765 let mut len = 0;
11766 if self.stream_message_batch.is_some() {
11767 len += 1;
11768 }
11769 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
11770 if let Some(v) = self.stream_message_batch.as_ref() {
11771 match v {
11772 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
11773 struct_ser.serialize_field("streamChunk", v)?;
11774 }
11775 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
11776 struct_ser.serialize_field("barrierBatch", v)?;
11777 }
11778 stream_message_batch::StreamMessageBatch::Watermark(v) => {
11779 struct_ser.serialize_field("watermark", v)?;
11780 }
11781 }
11782 }
11783 struct_ser.end()
11784 }
11785}
11786impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
11787 #[allow(deprecated)]
11788 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11789 where
11790 D: serde::Deserializer<'de>,
11791 {
11792 const FIELDS: &[&str] = &[
11793 "stream_chunk",
11794 "streamChunk",
11795 "barrier_batch",
11796 "barrierBatch",
11797 "watermark",
11798 ];
11799
11800 #[allow(clippy::enum_variant_names)]
11801 enum GeneratedField {
11802 StreamChunk,
11803 BarrierBatch,
11804 Watermark,
11805 }
11806 impl<'de> serde::Deserialize<'de> for GeneratedField {
11807 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11808 where
11809 D: serde::Deserializer<'de>,
11810 {
11811 struct GeneratedVisitor;
11812
11813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11814 type Value = GeneratedField;
11815
11816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11817 write!(formatter, "expected one of: {:?}", &FIELDS)
11818 }
11819
11820 #[allow(unused_variables)]
11821 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11822 where
11823 E: serde::de::Error,
11824 {
11825 match value {
11826 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11827 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
11828 "watermark" => Ok(GeneratedField::Watermark),
11829 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11830 }
11831 }
11832 }
11833 deserializer.deserialize_identifier(GeneratedVisitor)
11834 }
11835 }
11836 struct GeneratedVisitor;
11837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11838 type Value = StreamMessageBatch;
11839
11840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11841 formatter.write_str("struct stream_plan.StreamMessageBatch")
11842 }
11843
11844 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
11845 where
11846 V: serde::de::MapAccess<'de>,
11847 {
11848 let mut stream_message_batch__ = None;
11849 while let Some(k) = map_.next_key()? {
11850 match k {
11851 GeneratedField::StreamChunk => {
11852 if stream_message_batch__.is_some() {
11853 return Err(serde::de::Error::duplicate_field("streamChunk"));
11854 }
11855 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
11856;
11857 }
11858 GeneratedField::BarrierBatch => {
11859 if stream_message_batch__.is_some() {
11860 return Err(serde::de::Error::duplicate_field("barrierBatch"));
11861 }
11862 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
11863;
11864 }
11865 GeneratedField::Watermark => {
11866 if stream_message_batch__.is_some() {
11867 return Err(serde::de::Error::duplicate_field("watermark"));
11868 }
11869 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
11870;
11871 }
11872 }
11873 }
11874 Ok(StreamMessageBatch {
11875 stream_message_batch: stream_message_batch__,
11876 })
11877 }
11878 }
11879 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
11880 }
11881}
11882impl serde::Serialize for stream_message_batch::BarrierBatch {
11883 #[allow(deprecated)]
11884 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11885 where
11886 S: serde::Serializer,
11887 {
11888 use serde::ser::SerializeStruct;
11889 let mut len = 0;
11890 if !self.barriers.is_empty() {
11891 len += 1;
11892 }
11893 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
11894 if !self.barriers.is_empty() {
11895 struct_ser.serialize_field("barriers", &self.barriers)?;
11896 }
11897 struct_ser.end()
11898 }
11899}
11900impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
11901 #[allow(deprecated)]
11902 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11903 where
11904 D: serde::Deserializer<'de>,
11905 {
11906 const FIELDS: &[&str] = &[
11907 "barriers",
11908 ];
11909
11910 #[allow(clippy::enum_variant_names)]
11911 enum GeneratedField {
11912 Barriers,
11913 }
11914 impl<'de> serde::Deserialize<'de> for GeneratedField {
11915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11916 where
11917 D: serde::Deserializer<'de>,
11918 {
11919 struct GeneratedVisitor;
11920
11921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11922 type Value = GeneratedField;
11923
11924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11925 write!(formatter, "expected one of: {:?}", &FIELDS)
11926 }
11927
11928 #[allow(unused_variables)]
11929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11930 where
11931 E: serde::de::Error,
11932 {
11933 match value {
11934 "barriers" => Ok(GeneratedField::Barriers),
11935 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11936 }
11937 }
11938 }
11939 deserializer.deserialize_identifier(GeneratedVisitor)
11940 }
11941 }
11942 struct GeneratedVisitor;
11943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11944 type Value = stream_message_batch::BarrierBatch;
11945
11946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11947 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
11948 }
11949
11950 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
11951 where
11952 V: serde::de::MapAccess<'de>,
11953 {
11954 let mut barriers__ = None;
11955 while let Some(k) = map_.next_key()? {
11956 match k {
11957 GeneratedField::Barriers => {
11958 if barriers__.is_some() {
11959 return Err(serde::de::Error::duplicate_field("barriers"));
11960 }
11961 barriers__ = Some(map_.next_value()?);
11962 }
11963 }
11964 }
11965 Ok(stream_message_batch::BarrierBatch {
11966 barriers: barriers__.unwrap_or_default(),
11967 })
11968 }
11969 }
11970 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
11971 }
11972}
11973impl serde::Serialize for StreamNode {
11974 #[allow(deprecated)]
11975 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11976 where
11977 S: serde::Serializer,
11978 {
11979 use serde::ser::SerializeStruct;
11980 let mut len = 0;
11981 if self.operator_id != 0 {
11982 len += 1;
11983 }
11984 if !self.input.is_empty() {
11985 len += 1;
11986 }
11987 if !self.stream_key.is_empty() {
11988 len += 1;
11989 }
11990 if self.append_only {
11991 len += 1;
11992 }
11993 if !self.identity.is_empty() {
11994 len += 1;
11995 }
11996 if !self.fields.is_empty() {
11997 len += 1;
11998 }
11999 if self.node_body.is_some() {
12000 len += 1;
12001 }
12002 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12003 if self.operator_id != 0 {
12004 #[allow(clippy::needless_borrow)]
12005 #[allow(clippy::needless_borrows_for_generic_args)]
12006 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12007 }
12008 if !self.input.is_empty() {
12009 struct_ser.serialize_field("input", &self.input)?;
12010 }
12011 if !self.stream_key.is_empty() {
12012 struct_ser.serialize_field("streamKey", &self.stream_key)?;
12013 }
12014 if self.append_only {
12015 struct_ser.serialize_field("appendOnly", &self.append_only)?;
12016 }
12017 if !self.identity.is_empty() {
12018 struct_ser.serialize_field("identity", &self.identity)?;
12019 }
12020 if !self.fields.is_empty() {
12021 struct_ser.serialize_field("fields", &self.fields)?;
12022 }
12023 if let Some(v) = self.node_body.as_ref() {
12024 match v {
12025 stream_node::NodeBody::Source(v) => {
12026 struct_ser.serialize_field("source", v)?;
12027 }
12028 stream_node::NodeBody::Project(v) => {
12029 struct_ser.serialize_field("project", v)?;
12030 }
12031 stream_node::NodeBody::Filter(v) => {
12032 struct_ser.serialize_field("filter", v)?;
12033 }
12034 stream_node::NodeBody::Materialize(v) => {
12035 struct_ser.serialize_field("materialize", v)?;
12036 }
12037 stream_node::NodeBody::StatelessSimpleAgg(v) => {
12038 struct_ser.serialize_field("statelessSimpleAgg", v)?;
12039 }
12040 stream_node::NodeBody::SimpleAgg(v) => {
12041 struct_ser.serialize_field("simpleAgg", v)?;
12042 }
12043 stream_node::NodeBody::HashAgg(v) => {
12044 struct_ser.serialize_field("hashAgg", v)?;
12045 }
12046 stream_node::NodeBody::AppendOnlyTopN(v) => {
12047 struct_ser.serialize_field("appendOnlyTopN", v)?;
12048 }
12049 stream_node::NodeBody::HashJoin(v) => {
12050 struct_ser.serialize_field("hashJoin", v)?;
12051 }
12052 stream_node::NodeBody::TopN(v) => {
12053 struct_ser.serialize_field("topN", v)?;
12054 }
12055 stream_node::NodeBody::HopWindow(v) => {
12056 struct_ser.serialize_field("hopWindow", v)?;
12057 }
12058 stream_node::NodeBody::Merge(v) => {
12059 struct_ser.serialize_field("merge", v)?;
12060 }
12061 stream_node::NodeBody::Exchange(v) => {
12062 struct_ser.serialize_field("exchange", v)?;
12063 }
12064 stream_node::NodeBody::StreamScan(v) => {
12065 struct_ser.serialize_field("streamScan", v)?;
12066 }
12067 stream_node::NodeBody::BatchPlan(v) => {
12068 struct_ser.serialize_field("batchPlan", v)?;
12069 }
12070 stream_node::NodeBody::Lookup(v) => {
12071 struct_ser.serialize_field("lookup", v)?;
12072 }
12073 stream_node::NodeBody::Arrange(v) => {
12074 struct_ser.serialize_field("arrange", v)?;
12075 }
12076 stream_node::NodeBody::LookupUnion(v) => {
12077 struct_ser.serialize_field("lookupUnion", v)?;
12078 }
12079 stream_node::NodeBody::Union(v) => {
12080 struct_ser.serialize_field("union", v)?;
12081 }
12082 stream_node::NodeBody::DeltaIndexJoin(v) => {
12083 struct_ser.serialize_field("deltaIndexJoin", v)?;
12084 }
12085 stream_node::NodeBody::Sink(v) => {
12086 struct_ser.serialize_field("sink", v)?;
12087 }
12088 stream_node::NodeBody::Expand(v) => {
12089 struct_ser.serialize_field("expand", v)?;
12090 }
12091 stream_node::NodeBody::DynamicFilter(v) => {
12092 struct_ser.serialize_field("dynamicFilter", v)?;
12093 }
12094 stream_node::NodeBody::ProjectSet(v) => {
12095 struct_ser.serialize_field("projectSet", v)?;
12096 }
12097 stream_node::NodeBody::GroupTopN(v) => {
12098 struct_ser.serialize_field("groupTopN", v)?;
12099 }
12100 stream_node::NodeBody::Sort(v) => {
12101 struct_ser.serialize_field("sort", v)?;
12102 }
12103 stream_node::NodeBody::WatermarkFilter(v) => {
12104 struct_ser.serialize_field("watermarkFilter", v)?;
12105 }
12106 stream_node::NodeBody::Dml(v) => {
12107 struct_ser.serialize_field("dml", v)?;
12108 }
12109 stream_node::NodeBody::RowIdGen(v) => {
12110 struct_ser.serialize_field("rowIdGen", v)?;
12111 }
12112 stream_node::NodeBody::Now(v) => {
12113 struct_ser.serialize_field("now", v)?;
12114 }
12115 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
12116 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
12117 }
12118 stream_node::NodeBody::TemporalJoin(v) => {
12119 struct_ser.serialize_field("temporalJoin", v)?;
12120 }
12121 stream_node::NodeBody::BarrierRecv(v) => {
12122 struct_ser.serialize_field("barrierRecv", v)?;
12123 }
12124 stream_node::NodeBody::Values(v) => {
12125 struct_ser.serialize_field("values", v)?;
12126 }
12127 stream_node::NodeBody::AppendOnlyDedup(v) => {
12128 struct_ser.serialize_field("appendOnlyDedup", v)?;
12129 }
12130 stream_node::NodeBody::NoOp(v) => {
12131 struct_ser.serialize_field("noOp", v)?;
12132 }
12133 stream_node::NodeBody::EowcOverWindow(v) => {
12134 struct_ser.serialize_field("eowcOverWindow", v)?;
12135 }
12136 stream_node::NodeBody::OverWindow(v) => {
12137 struct_ser.serialize_field("overWindow", v)?;
12138 }
12139 stream_node::NodeBody::StreamFsFetch(v) => {
12140 struct_ser.serialize_field("streamFsFetch", v)?;
12141 }
12142 stream_node::NodeBody::StreamCdcScan(v) => {
12143 struct_ser.serialize_field("streamCdcScan", v)?;
12144 }
12145 stream_node::NodeBody::CdcFilter(v) => {
12146 struct_ser.serialize_field("cdcFilter", v)?;
12147 }
12148 stream_node::NodeBody::SourceBackfill(v) => {
12149 struct_ser.serialize_field("sourceBackfill", v)?;
12150 }
12151 stream_node::NodeBody::Changelog(v) => {
12152 struct_ser.serialize_field("changelog", v)?;
12153 }
12154 stream_node::NodeBody::LocalApproxPercentile(v) => {
12155 struct_ser.serialize_field("localApproxPercentile", v)?;
12156 }
12157 stream_node::NodeBody::GlobalApproxPercentile(v) => {
12158 struct_ser.serialize_field("globalApproxPercentile", v)?;
12159 }
12160 stream_node::NodeBody::RowMerge(v) => {
12161 struct_ser.serialize_field("rowMerge", v)?;
12162 }
12163 stream_node::NodeBody::AsOfJoin(v) => {
12164 struct_ser.serialize_field("asOfJoin", v)?;
12165 }
12166 stream_node::NodeBody::SyncLogStore(v) => {
12167 struct_ser.serialize_field("syncLogStore", v)?;
12168 }
12169 stream_node::NodeBody::MaterializedExprs(v) => {
12170 struct_ser.serialize_field("materializedExprs", v)?;
12171 }
12172 stream_node::NodeBody::VectorIndexWrite(v) => {
12173 struct_ser.serialize_field("vectorIndexWrite", v)?;
12174 }
12175 }
12176 }
12177 struct_ser.end()
12178 }
12179}
12180impl<'de> serde::Deserialize<'de> for StreamNode {
12181 #[allow(deprecated)]
12182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12183 where
12184 D: serde::Deserializer<'de>,
12185 {
12186 const FIELDS: &[&str] = &[
12187 "operator_id",
12188 "operatorId",
12189 "input",
12190 "stream_key",
12191 "streamKey",
12192 "append_only",
12193 "appendOnly",
12194 "identity",
12195 "fields",
12196 "source",
12197 "project",
12198 "filter",
12199 "materialize",
12200 "stateless_simple_agg",
12201 "statelessSimpleAgg",
12202 "simple_agg",
12203 "simpleAgg",
12204 "hash_agg",
12205 "hashAgg",
12206 "append_only_top_n",
12207 "appendOnlyTopN",
12208 "hash_join",
12209 "hashJoin",
12210 "top_n",
12211 "topN",
12212 "hop_window",
12213 "hopWindow",
12214 "merge",
12215 "exchange",
12216 "stream_scan",
12217 "streamScan",
12218 "batch_plan",
12219 "batchPlan",
12220 "lookup",
12221 "arrange",
12222 "lookup_union",
12223 "lookupUnion",
12224 "union",
12225 "delta_index_join",
12226 "deltaIndexJoin",
12227 "sink",
12228 "expand",
12229 "dynamic_filter",
12230 "dynamicFilter",
12231 "project_set",
12232 "projectSet",
12233 "group_top_n",
12234 "groupTopN",
12235 "sort",
12236 "watermark_filter",
12237 "watermarkFilter",
12238 "dml",
12239 "row_id_gen",
12240 "rowIdGen",
12241 "now",
12242 "append_only_group_top_n",
12243 "appendOnlyGroupTopN",
12244 "temporal_join",
12245 "temporalJoin",
12246 "barrier_recv",
12247 "barrierRecv",
12248 "values",
12249 "append_only_dedup",
12250 "appendOnlyDedup",
12251 "no_op",
12252 "noOp",
12253 "eowc_over_window",
12254 "eowcOverWindow",
12255 "over_window",
12256 "overWindow",
12257 "stream_fs_fetch",
12258 "streamFsFetch",
12259 "stream_cdc_scan",
12260 "streamCdcScan",
12261 "cdc_filter",
12262 "cdcFilter",
12263 "source_backfill",
12264 "sourceBackfill",
12265 "changelog",
12266 "local_approx_percentile",
12267 "localApproxPercentile",
12268 "global_approx_percentile",
12269 "globalApproxPercentile",
12270 "row_merge",
12271 "rowMerge",
12272 "as_of_join",
12273 "asOfJoin",
12274 "sync_log_store",
12275 "syncLogStore",
12276 "materialized_exprs",
12277 "materializedExprs",
12278 "vector_index_write",
12279 "vectorIndexWrite",
12280 ];
12281
12282 #[allow(clippy::enum_variant_names)]
12283 enum GeneratedField {
12284 OperatorId,
12285 Input,
12286 StreamKey,
12287 AppendOnly,
12288 Identity,
12289 Fields,
12290 Source,
12291 Project,
12292 Filter,
12293 Materialize,
12294 StatelessSimpleAgg,
12295 SimpleAgg,
12296 HashAgg,
12297 AppendOnlyTopN,
12298 HashJoin,
12299 TopN,
12300 HopWindow,
12301 Merge,
12302 Exchange,
12303 StreamScan,
12304 BatchPlan,
12305 Lookup,
12306 Arrange,
12307 LookupUnion,
12308 Union,
12309 DeltaIndexJoin,
12310 Sink,
12311 Expand,
12312 DynamicFilter,
12313 ProjectSet,
12314 GroupTopN,
12315 Sort,
12316 WatermarkFilter,
12317 Dml,
12318 RowIdGen,
12319 Now,
12320 AppendOnlyGroupTopN,
12321 TemporalJoin,
12322 BarrierRecv,
12323 Values,
12324 AppendOnlyDedup,
12325 NoOp,
12326 EowcOverWindow,
12327 OverWindow,
12328 StreamFsFetch,
12329 StreamCdcScan,
12330 CdcFilter,
12331 SourceBackfill,
12332 Changelog,
12333 LocalApproxPercentile,
12334 GlobalApproxPercentile,
12335 RowMerge,
12336 AsOfJoin,
12337 SyncLogStore,
12338 MaterializedExprs,
12339 VectorIndexWrite,
12340 }
12341 impl<'de> serde::Deserialize<'de> for GeneratedField {
12342 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12343 where
12344 D: serde::Deserializer<'de>,
12345 {
12346 struct GeneratedVisitor;
12347
12348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12349 type Value = GeneratedField;
12350
12351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12352 write!(formatter, "expected one of: {:?}", &FIELDS)
12353 }
12354
12355 #[allow(unused_variables)]
12356 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12357 where
12358 E: serde::de::Error,
12359 {
12360 match value {
12361 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
12362 "input" => Ok(GeneratedField::Input),
12363 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
12364 "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
12365 "identity" => Ok(GeneratedField::Identity),
12366 "fields" => Ok(GeneratedField::Fields),
12367 "source" => Ok(GeneratedField::Source),
12368 "project" => Ok(GeneratedField::Project),
12369 "filter" => Ok(GeneratedField::Filter),
12370 "materialize" => Ok(GeneratedField::Materialize),
12371 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
12372 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
12373 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
12374 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
12375 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
12376 "topN" | "top_n" => Ok(GeneratedField::TopN),
12377 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
12378 "merge" => Ok(GeneratedField::Merge),
12379 "exchange" => Ok(GeneratedField::Exchange),
12380 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
12381 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
12382 "lookup" => Ok(GeneratedField::Lookup),
12383 "arrange" => Ok(GeneratedField::Arrange),
12384 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
12385 "union" => Ok(GeneratedField::Union),
12386 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
12387 "sink" => Ok(GeneratedField::Sink),
12388 "expand" => Ok(GeneratedField::Expand),
12389 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
12390 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
12391 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
12392 "sort" => Ok(GeneratedField::Sort),
12393 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
12394 "dml" => Ok(GeneratedField::Dml),
12395 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
12396 "now" => Ok(GeneratedField::Now),
12397 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
12398 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
12399 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
12400 "values" => Ok(GeneratedField::Values),
12401 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
12402 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
12403 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
12404 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
12405 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
12406 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
12407 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
12408 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
12409 "changelog" => Ok(GeneratedField::Changelog),
12410 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
12411 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
12412 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
12413 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
12414 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
12415 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
12416 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
12417 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12418 }
12419 }
12420 }
12421 deserializer.deserialize_identifier(GeneratedVisitor)
12422 }
12423 }
12424 struct GeneratedVisitor;
12425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12426 type Value = StreamNode;
12427
12428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12429 formatter.write_str("struct stream_plan.StreamNode")
12430 }
12431
12432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
12433 where
12434 V: serde::de::MapAccess<'de>,
12435 {
12436 let mut operator_id__ = None;
12437 let mut input__ = None;
12438 let mut stream_key__ = None;
12439 let mut append_only__ = None;
12440 let mut identity__ = None;
12441 let mut fields__ = None;
12442 let mut node_body__ = None;
12443 while let Some(k) = map_.next_key()? {
12444 match k {
12445 GeneratedField::OperatorId => {
12446 if operator_id__.is_some() {
12447 return Err(serde::de::Error::duplicate_field("operatorId"));
12448 }
12449 operator_id__ =
12450 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12451 ;
12452 }
12453 GeneratedField::Input => {
12454 if input__.is_some() {
12455 return Err(serde::de::Error::duplicate_field("input"));
12456 }
12457 input__ = Some(map_.next_value()?);
12458 }
12459 GeneratedField::StreamKey => {
12460 if stream_key__.is_some() {
12461 return Err(serde::de::Error::duplicate_field("streamKey"));
12462 }
12463 stream_key__ =
12464 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12465 .into_iter().map(|x| x.0).collect())
12466 ;
12467 }
12468 GeneratedField::AppendOnly => {
12469 if append_only__.is_some() {
12470 return Err(serde::de::Error::duplicate_field("appendOnly"));
12471 }
12472 append_only__ = Some(map_.next_value()?);
12473 }
12474 GeneratedField::Identity => {
12475 if identity__.is_some() {
12476 return Err(serde::de::Error::duplicate_field("identity"));
12477 }
12478 identity__ = Some(map_.next_value()?);
12479 }
12480 GeneratedField::Fields => {
12481 if fields__.is_some() {
12482 return Err(serde::de::Error::duplicate_field("fields"));
12483 }
12484 fields__ = Some(map_.next_value()?);
12485 }
12486 GeneratedField::Source => {
12487 if node_body__.is_some() {
12488 return Err(serde::de::Error::duplicate_field("source"));
12489 }
12490 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12491;
12492 }
12493 GeneratedField::Project => {
12494 if node_body__.is_some() {
12495 return Err(serde::de::Error::duplicate_field("project"));
12496 }
12497 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12498;
12499 }
12500 GeneratedField::Filter => {
12501 if node_body__.is_some() {
12502 return Err(serde::de::Error::duplicate_field("filter"));
12503 }
12504 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12505;
12506 }
12507 GeneratedField::Materialize => {
12508 if node_body__.is_some() {
12509 return Err(serde::de::Error::duplicate_field("materialize"));
12510 }
12511 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12512;
12513 }
12514 GeneratedField::StatelessSimpleAgg => {
12515 if node_body__.is_some() {
12516 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12517 }
12518 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12519;
12520 }
12521 GeneratedField::SimpleAgg => {
12522 if node_body__.is_some() {
12523 return Err(serde::de::Error::duplicate_field("simpleAgg"));
12524 }
12525 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12526;
12527 }
12528 GeneratedField::HashAgg => {
12529 if node_body__.is_some() {
12530 return Err(serde::de::Error::duplicate_field("hashAgg"));
12531 }
12532 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12533;
12534 }
12535 GeneratedField::AppendOnlyTopN => {
12536 if node_body__.is_some() {
12537 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12538 }
12539 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12540;
12541 }
12542 GeneratedField::HashJoin => {
12543 if node_body__.is_some() {
12544 return Err(serde::de::Error::duplicate_field("hashJoin"));
12545 }
12546 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12547;
12548 }
12549 GeneratedField::TopN => {
12550 if node_body__.is_some() {
12551 return Err(serde::de::Error::duplicate_field("topN"));
12552 }
12553 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12554;
12555 }
12556 GeneratedField::HopWindow => {
12557 if node_body__.is_some() {
12558 return Err(serde::de::Error::duplicate_field("hopWindow"));
12559 }
12560 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12561;
12562 }
12563 GeneratedField::Merge => {
12564 if node_body__.is_some() {
12565 return Err(serde::de::Error::duplicate_field("merge"));
12566 }
12567 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12568;
12569 }
12570 GeneratedField::Exchange => {
12571 if node_body__.is_some() {
12572 return Err(serde::de::Error::duplicate_field("exchange"));
12573 }
12574 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12575;
12576 }
12577 GeneratedField::StreamScan => {
12578 if node_body__.is_some() {
12579 return Err(serde::de::Error::duplicate_field("streamScan"));
12580 }
12581 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12582;
12583 }
12584 GeneratedField::BatchPlan => {
12585 if node_body__.is_some() {
12586 return Err(serde::de::Error::duplicate_field("batchPlan"));
12587 }
12588 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12589;
12590 }
12591 GeneratedField::Lookup => {
12592 if node_body__.is_some() {
12593 return Err(serde::de::Error::duplicate_field("lookup"));
12594 }
12595 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12596;
12597 }
12598 GeneratedField::Arrange => {
12599 if node_body__.is_some() {
12600 return Err(serde::de::Error::duplicate_field("arrange"));
12601 }
12602 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12603;
12604 }
12605 GeneratedField::LookupUnion => {
12606 if node_body__.is_some() {
12607 return Err(serde::de::Error::duplicate_field("lookupUnion"));
12608 }
12609 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12610;
12611 }
12612 GeneratedField::Union => {
12613 if node_body__.is_some() {
12614 return Err(serde::de::Error::duplicate_field("union"));
12615 }
12616 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12617;
12618 }
12619 GeneratedField::DeltaIndexJoin => {
12620 if node_body__.is_some() {
12621 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12622 }
12623 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12624;
12625 }
12626 GeneratedField::Sink => {
12627 if node_body__.is_some() {
12628 return Err(serde::de::Error::duplicate_field("sink"));
12629 }
12630 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12631;
12632 }
12633 GeneratedField::Expand => {
12634 if node_body__.is_some() {
12635 return Err(serde::de::Error::duplicate_field("expand"));
12636 }
12637 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12638;
12639 }
12640 GeneratedField::DynamicFilter => {
12641 if node_body__.is_some() {
12642 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12643 }
12644 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12645;
12646 }
12647 GeneratedField::ProjectSet => {
12648 if node_body__.is_some() {
12649 return Err(serde::de::Error::duplicate_field("projectSet"));
12650 }
12651 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12652;
12653 }
12654 GeneratedField::GroupTopN => {
12655 if node_body__.is_some() {
12656 return Err(serde::de::Error::duplicate_field("groupTopN"));
12657 }
12658 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12659;
12660 }
12661 GeneratedField::Sort => {
12662 if node_body__.is_some() {
12663 return Err(serde::de::Error::duplicate_field("sort"));
12664 }
12665 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12666;
12667 }
12668 GeneratedField::WatermarkFilter => {
12669 if node_body__.is_some() {
12670 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12671 }
12672 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12673;
12674 }
12675 GeneratedField::Dml => {
12676 if node_body__.is_some() {
12677 return Err(serde::de::Error::duplicate_field("dml"));
12678 }
12679 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12680;
12681 }
12682 GeneratedField::RowIdGen => {
12683 if node_body__.is_some() {
12684 return Err(serde::de::Error::duplicate_field("rowIdGen"));
12685 }
12686 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12687;
12688 }
12689 GeneratedField::Now => {
12690 if node_body__.is_some() {
12691 return Err(serde::de::Error::duplicate_field("now"));
12692 }
12693 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12694;
12695 }
12696 GeneratedField::AppendOnlyGroupTopN => {
12697 if node_body__.is_some() {
12698 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
12699 }
12700 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
12701;
12702 }
12703 GeneratedField::TemporalJoin => {
12704 if node_body__.is_some() {
12705 return Err(serde::de::Error::duplicate_field("temporalJoin"));
12706 }
12707 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
12708;
12709 }
12710 GeneratedField::BarrierRecv => {
12711 if node_body__.is_some() {
12712 return Err(serde::de::Error::duplicate_field("barrierRecv"));
12713 }
12714 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
12715;
12716 }
12717 GeneratedField::Values => {
12718 if node_body__.is_some() {
12719 return Err(serde::de::Error::duplicate_field("values"));
12720 }
12721 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
12722;
12723 }
12724 GeneratedField::AppendOnlyDedup => {
12725 if node_body__.is_some() {
12726 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
12727 }
12728 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
12729;
12730 }
12731 GeneratedField::NoOp => {
12732 if node_body__.is_some() {
12733 return Err(serde::de::Error::duplicate_field("noOp"));
12734 }
12735 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
12736;
12737 }
12738 GeneratedField::EowcOverWindow => {
12739 if node_body__.is_some() {
12740 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
12741 }
12742 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
12743;
12744 }
12745 GeneratedField::OverWindow => {
12746 if node_body__.is_some() {
12747 return Err(serde::de::Error::duplicate_field("overWindow"));
12748 }
12749 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
12750;
12751 }
12752 GeneratedField::StreamFsFetch => {
12753 if node_body__.is_some() {
12754 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
12755 }
12756 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
12757;
12758 }
12759 GeneratedField::StreamCdcScan => {
12760 if node_body__.is_some() {
12761 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
12762 }
12763 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
12764;
12765 }
12766 GeneratedField::CdcFilter => {
12767 if node_body__.is_some() {
12768 return Err(serde::de::Error::duplicate_field("cdcFilter"));
12769 }
12770 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
12771;
12772 }
12773 GeneratedField::SourceBackfill => {
12774 if node_body__.is_some() {
12775 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
12776 }
12777 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
12778;
12779 }
12780 GeneratedField::Changelog => {
12781 if node_body__.is_some() {
12782 return Err(serde::de::Error::duplicate_field("changelog"));
12783 }
12784 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
12785;
12786 }
12787 GeneratedField::LocalApproxPercentile => {
12788 if node_body__.is_some() {
12789 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
12790 }
12791 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
12792;
12793 }
12794 GeneratedField::GlobalApproxPercentile => {
12795 if node_body__.is_some() {
12796 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
12797 }
12798 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
12799;
12800 }
12801 GeneratedField::RowMerge => {
12802 if node_body__.is_some() {
12803 return Err(serde::de::Error::duplicate_field("rowMerge"));
12804 }
12805 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
12806;
12807 }
12808 GeneratedField::AsOfJoin => {
12809 if node_body__.is_some() {
12810 return Err(serde::de::Error::duplicate_field("asOfJoin"));
12811 }
12812 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
12813;
12814 }
12815 GeneratedField::SyncLogStore => {
12816 if node_body__.is_some() {
12817 return Err(serde::de::Error::duplicate_field("syncLogStore"));
12818 }
12819 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
12820;
12821 }
12822 GeneratedField::MaterializedExprs => {
12823 if node_body__.is_some() {
12824 return Err(serde::de::Error::duplicate_field("materializedExprs"));
12825 }
12826 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
12827;
12828 }
12829 GeneratedField::VectorIndexWrite => {
12830 if node_body__.is_some() {
12831 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
12832 }
12833 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
12834;
12835 }
12836 }
12837 }
12838 Ok(StreamNode {
12839 operator_id: operator_id__.unwrap_or_default(),
12840 input: input__.unwrap_or_default(),
12841 stream_key: stream_key__.unwrap_or_default(),
12842 append_only: append_only__.unwrap_or_default(),
12843 identity: identity__.unwrap_or_default(),
12844 fields: fields__.unwrap_or_default(),
12845 node_body: node_body__,
12846 })
12847 }
12848 }
12849 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
12850 }
12851}
12852impl serde::Serialize for StreamScanNode {
12853 #[allow(deprecated)]
12854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12855 where
12856 S: serde::Serializer,
12857 {
12858 use serde::ser::SerializeStruct;
12859 let mut len = 0;
12860 if self.table_id != 0 {
12861 len += 1;
12862 }
12863 if !self.upstream_column_ids.is_empty() {
12864 len += 1;
12865 }
12866 if !self.output_indices.is_empty() {
12867 len += 1;
12868 }
12869 if self.stream_scan_type != 0 {
12870 len += 1;
12871 }
12872 if self.state_table.is_some() {
12873 len += 1;
12874 }
12875 if self.table_desc.is_some() {
12876 len += 1;
12877 }
12878 if self.rate_limit.is_some() {
12879 len += 1;
12880 }
12881 if self.snapshot_read_barrier_interval != 0 {
12882 len += 1;
12883 }
12884 if self.arrangement_table.is_some() {
12885 len += 1;
12886 }
12887 if self.snapshot_backfill_epoch.is_some() {
12888 len += 1;
12889 }
12890 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
12891 if self.table_id != 0 {
12892 struct_ser.serialize_field("tableId", &self.table_id)?;
12893 }
12894 if !self.upstream_column_ids.is_empty() {
12895 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12896 }
12897 if !self.output_indices.is_empty() {
12898 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12899 }
12900 if self.stream_scan_type != 0 {
12901 let v = StreamScanType::try_from(self.stream_scan_type)
12902 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
12903 struct_ser.serialize_field("streamScanType", &v)?;
12904 }
12905 if let Some(v) = self.state_table.as_ref() {
12906 struct_ser.serialize_field("stateTable", v)?;
12907 }
12908 if let Some(v) = self.table_desc.as_ref() {
12909 struct_ser.serialize_field("tableDesc", v)?;
12910 }
12911 if let Some(v) = self.rate_limit.as_ref() {
12912 struct_ser.serialize_field("rateLimit", v)?;
12913 }
12914 if self.snapshot_read_barrier_interval != 0 {
12915 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
12916 }
12917 if let Some(v) = self.arrangement_table.as_ref() {
12918 struct_ser.serialize_field("arrangementTable", v)?;
12919 }
12920 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
12921 #[allow(clippy::needless_borrow)]
12922 #[allow(clippy::needless_borrows_for_generic_args)]
12923 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
12924 }
12925 struct_ser.end()
12926 }
12927}
12928impl<'de> serde::Deserialize<'de> for StreamScanNode {
12929 #[allow(deprecated)]
12930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12931 where
12932 D: serde::Deserializer<'de>,
12933 {
12934 const FIELDS: &[&str] = &[
12935 "table_id",
12936 "tableId",
12937 "upstream_column_ids",
12938 "upstreamColumnIds",
12939 "output_indices",
12940 "outputIndices",
12941 "stream_scan_type",
12942 "streamScanType",
12943 "state_table",
12944 "stateTable",
12945 "table_desc",
12946 "tableDesc",
12947 "rate_limit",
12948 "rateLimit",
12949 "snapshot_read_barrier_interval",
12950 "snapshotReadBarrierInterval",
12951 "arrangement_table",
12952 "arrangementTable",
12953 "snapshot_backfill_epoch",
12954 "snapshotBackfillEpoch",
12955 ];
12956
12957 #[allow(clippy::enum_variant_names)]
12958 enum GeneratedField {
12959 TableId,
12960 UpstreamColumnIds,
12961 OutputIndices,
12962 StreamScanType,
12963 StateTable,
12964 TableDesc,
12965 RateLimit,
12966 SnapshotReadBarrierInterval,
12967 ArrangementTable,
12968 SnapshotBackfillEpoch,
12969 }
12970 impl<'de> serde::Deserialize<'de> for GeneratedField {
12971 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12972 where
12973 D: serde::Deserializer<'de>,
12974 {
12975 struct GeneratedVisitor;
12976
12977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12978 type Value = GeneratedField;
12979
12980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12981 write!(formatter, "expected one of: {:?}", &FIELDS)
12982 }
12983
12984 #[allow(unused_variables)]
12985 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12986 where
12987 E: serde::de::Error,
12988 {
12989 match value {
12990 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12991 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12992 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12993 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
12994 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12995 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
12996 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12997 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
12998 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
12999 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
13000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13001 }
13002 }
13003 }
13004 deserializer.deserialize_identifier(GeneratedVisitor)
13005 }
13006 }
13007 struct GeneratedVisitor;
13008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13009 type Value = StreamScanNode;
13010
13011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13012 formatter.write_str("struct stream_plan.StreamScanNode")
13013 }
13014
13015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
13016 where
13017 V: serde::de::MapAccess<'de>,
13018 {
13019 let mut table_id__ = None;
13020 let mut upstream_column_ids__ = None;
13021 let mut output_indices__ = None;
13022 let mut stream_scan_type__ = None;
13023 let mut state_table__ = None;
13024 let mut table_desc__ = None;
13025 let mut rate_limit__ = None;
13026 let mut snapshot_read_barrier_interval__ = None;
13027 let mut arrangement_table__ = None;
13028 let mut snapshot_backfill_epoch__ = None;
13029 while let Some(k) = map_.next_key()? {
13030 match k {
13031 GeneratedField::TableId => {
13032 if table_id__.is_some() {
13033 return Err(serde::de::Error::duplicate_field("tableId"));
13034 }
13035 table_id__ =
13036 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13037 ;
13038 }
13039 GeneratedField::UpstreamColumnIds => {
13040 if upstream_column_ids__.is_some() {
13041 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
13042 }
13043 upstream_column_ids__ =
13044 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13045 .into_iter().map(|x| x.0).collect())
13046 ;
13047 }
13048 GeneratedField::OutputIndices => {
13049 if output_indices__.is_some() {
13050 return Err(serde::de::Error::duplicate_field("outputIndices"));
13051 }
13052 output_indices__ =
13053 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13054 .into_iter().map(|x| x.0).collect())
13055 ;
13056 }
13057 GeneratedField::StreamScanType => {
13058 if stream_scan_type__.is_some() {
13059 return Err(serde::de::Error::duplicate_field("streamScanType"));
13060 }
13061 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
13062 }
13063 GeneratedField::StateTable => {
13064 if state_table__.is_some() {
13065 return Err(serde::de::Error::duplicate_field("stateTable"));
13066 }
13067 state_table__ = map_.next_value()?;
13068 }
13069 GeneratedField::TableDesc => {
13070 if table_desc__.is_some() {
13071 return Err(serde::de::Error::duplicate_field("tableDesc"));
13072 }
13073 table_desc__ = map_.next_value()?;
13074 }
13075 GeneratedField::RateLimit => {
13076 if rate_limit__.is_some() {
13077 return Err(serde::de::Error::duplicate_field("rateLimit"));
13078 }
13079 rate_limit__ =
13080 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13081 ;
13082 }
13083 GeneratedField::SnapshotReadBarrierInterval => {
13084 if snapshot_read_barrier_interval__.is_some() {
13085 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
13086 }
13087 snapshot_read_barrier_interval__ =
13088 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13089 ;
13090 }
13091 GeneratedField::ArrangementTable => {
13092 if arrangement_table__.is_some() {
13093 return Err(serde::de::Error::duplicate_field("arrangementTable"));
13094 }
13095 arrangement_table__ = map_.next_value()?;
13096 }
13097 GeneratedField::SnapshotBackfillEpoch => {
13098 if snapshot_backfill_epoch__.is_some() {
13099 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
13100 }
13101 snapshot_backfill_epoch__ =
13102 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13103 ;
13104 }
13105 }
13106 }
13107 Ok(StreamScanNode {
13108 table_id: table_id__.unwrap_or_default(),
13109 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
13110 output_indices: output_indices__.unwrap_or_default(),
13111 stream_scan_type: stream_scan_type__.unwrap_or_default(),
13112 state_table: state_table__,
13113 table_desc: table_desc__,
13114 rate_limit: rate_limit__,
13115 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
13116 arrangement_table: arrangement_table__,
13117 snapshot_backfill_epoch: snapshot_backfill_epoch__,
13118 })
13119 }
13120 }
13121 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
13122 }
13123}
13124impl serde::Serialize for StreamScanType {
13125 #[allow(deprecated)]
13126 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13127 where
13128 S: serde::Serializer,
13129 {
13130 let variant = match self {
13131 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
13132 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
13133 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
13134 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
13135 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13136 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13137 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13138 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13139 };
13140 serializer.serialize_str(variant)
13141 }
13142}
13143impl<'de> serde::Deserialize<'de> for StreamScanType {
13144 #[allow(deprecated)]
13145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13146 where
13147 D: serde::Deserializer<'de>,
13148 {
13149 const FIELDS: &[&str] = &[
13150 "STREAM_SCAN_TYPE_UNSPECIFIED",
13151 "STREAM_SCAN_TYPE_CHAIN",
13152 "STREAM_SCAN_TYPE_REARRANGE",
13153 "STREAM_SCAN_TYPE_BACKFILL",
13154 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13155 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13156 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13157 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13158 ];
13159
13160 struct GeneratedVisitor;
13161
13162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13163 type Value = StreamScanType;
13164
13165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13166 write!(formatter, "expected one of: {:?}", &FIELDS)
13167 }
13168
13169 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13170 where
13171 E: serde::de::Error,
13172 {
13173 i32::try_from(v)
13174 .ok()
13175 .and_then(|x| x.try_into().ok())
13176 .ok_or_else(|| {
13177 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13178 })
13179 }
13180
13181 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13182 where
13183 E: serde::de::Error,
13184 {
13185 i32::try_from(v)
13186 .ok()
13187 .and_then(|x| x.try_into().ok())
13188 .ok_or_else(|| {
13189 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13190 })
13191 }
13192
13193 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13194 where
13195 E: serde::de::Error,
13196 {
13197 match value {
13198 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
13199 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
13200 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
13201 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
13202 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
13203 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
13204 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
13205 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
13206 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13207 }
13208 }
13209 }
13210 deserializer.deserialize_any(GeneratedVisitor)
13211 }
13212}
13213impl serde::Serialize for StreamSource {
13214 #[allow(deprecated)]
13215 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13216 where
13217 S: serde::Serializer,
13218 {
13219 use serde::ser::SerializeStruct;
13220 let mut len = 0;
13221 if self.source_id != 0 {
13222 len += 1;
13223 }
13224 if self.state_table.is_some() {
13225 len += 1;
13226 }
13227 if self.row_id_index.is_some() {
13228 len += 1;
13229 }
13230 if !self.columns.is_empty() {
13231 len += 1;
13232 }
13233 if !self.with_properties.is_empty() {
13234 len += 1;
13235 }
13236 if self.info.is_some() {
13237 len += 1;
13238 }
13239 if !self.source_name.is_empty() {
13240 len += 1;
13241 }
13242 if self.rate_limit.is_some() {
13243 len += 1;
13244 }
13245 if !self.secret_refs.is_empty() {
13246 len += 1;
13247 }
13248 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
13249 if self.source_id != 0 {
13250 struct_ser.serialize_field("sourceId", &self.source_id)?;
13251 }
13252 if let Some(v) = self.state_table.as_ref() {
13253 struct_ser.serialize_field("stateTable", v)?;
13254 }
13255 if let Some(v) = self.row_id_index.as_ref() {
13256 struct_ser.serialize_field("rowIdIndex", v)?;
13257 }
13258 if !self.columns.is_empty() {
13259 struct_ser.serialize_field("columns", &self.columns)?;
13260 }
13261 if !self.with_properties.is_empty() {
13262 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13263 }
13264 if let Some(v) = self.info.as_ref() {
13265 struct_ser.serialize_field("info", v)?;
13266 }
13267 if !self.source_name.is_empty() {
13268 struct_ser.serialize_field("sourceName", &self.source_name)?;
13269 }
13270 if let Some(v) = self.rate_limit.as_ref() {
13271 struct_ser.serialize_field("rateLimit", v)?;
13272 }
13273 if !self.secret_refs.is_empty() {
13274 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13275 }
13276 struct_ser.end()
13277 }
13278}
13279impl<'de> serde::Deserialize<'de> for StreamSource {
13280 #[allow(deprecated)]
13281 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13282 where
13283 D: serde::Deserializer<'de>,
13284 {
13285 const FIELDS: &[&str] = &[
13286 "source_id",
13287 "sourceId",
13288 "state_table",
13289 "stateTable",
13290 "row_id_index",
13291 "rowIdIndex",
13292 "columns",
13293 "with_properties",
13294 "withProperties",
13295 "info",
13296 "source_name",
13297 "sourceName",
13298 "rate_limit",
13299 "rateLimit",
13300 "secret_refs",
13301 "secretRefs",
13302 ];
13303
13304 #[allow(clippy::enum_variant_names)]
13305 enum GeneratedField {
13306 SourceId,
13307 StateTable,
13308 RowIdIndex,
13309 Columns,
13310 WithProperties,
13311 Info,
13312 SourceName,
13313 RateLimit,
13314 SecretRefs,
13315 }
13316 impl<'de> serde::Deserialize<'de> for GeneratedField {
13317 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13318 where
13319 D: serde::Deserializer<'de>,
13320 {
13321 struct GeneratedVisitor;
13322
13323 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13324 type Value = GeneratedField;
13325
13326 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13327 write!(formatter, "expected one of: {:?}", &FIELDS)
13328 }
13329
13330 #[allow(unused_variables)]
13331 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13332 where
13333 E: serde::de::Error,
13334 {
13335 match value {
13336 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13337 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13338 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13339 "columns" => Ok(GeneratedField::Columns),
13340 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13341 "info" => Ok(GeneratedField::Info),
13342 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13343 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13344 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13345 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13346 }
13347 }
13348 }
13349 deserializer.deserialize_identifier(GeneratedVisitor)
13350 }
13351 }
13352 struct GeneratedVisitor;
13353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13354 type Value = StreamSource;
13355
13356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13357 formatter.write_str("struct stream_plan.StreamSource")
13358 }
13359
13360 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
13361 where
13362 V: serde::de::MapAccess<'de>,
13363 {
13364 let mut source_id__ = None;
13365 let mut state_table__ = None;
13366 let mut row_id_index__ = None;
13367 let mut columns__ = None;
13368 let mut with_properties__ = None;
13369 let mut info__ = None;
13370 let mut source_name__ = None;
13371 let mut rate_limit__ = None;
13372 let mut secret_refs__ = None;
13373 while let Some(k) = map_.next_key()? {
13374 match k {
13375 GeneratedField::SourceId => {
13376 if source_id__.is_some() {
13377 return Err(serde::de::Error::duplicate_field("sourceId"));
13378 }
13379 source_id__ =
13380 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13381 ;
13382 }
13383 GeneratedField::StateTable => {
13384 if state_table__.is_some() {
13385 return Err(serde::de::Error::duplicate_field("stateTable"));
13386 }
13387 state_table__ = map_.next_value()?;
13388 }
13389 GeneratedField::RowIdIndex => {
13390 if row_id_index__.is_some() {
13391 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13392 }
13393 row_id_index__ =
13394 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13395 ;
13396 }
13397 GeneratedField::Columns => {
13398 if columns__.is_some() {
13399 return Err(serde::de::Error::duplicate_field("columns"));
13400 }
13401 columns__ = Some(map_.next_value()?);
13402 }
13403 GeneratedField::WithProperties => {
13404 if with_properties__.is_some() {
13405 return Err(serde::de::Error::duplicate_field("withProperties"));
13406 }
13407 with_properties__ = Some(
13408 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13409 );
13410 }
13411 GeneratedField::Info => {
13412 if info__.is_some() {
13413 return Err(serde::de::Error::duplicate_field("info"));
13414 }
13415 info__ = map_.next_value()?;
13416 }
13417 GeneratedField::SourceName => {
13418 if source_name__.is_some() {
13419 return Err(serde::de::Error::duplicate_field("sourceName"));
13420 }
13421 source_name__ = Some(map_.next_value()?);
13422 }
13423 GeneratedField::RateLimit => {
13424 if rate_limit__.is_some() {
13425 return Err(serde::de::Error::duplicate_field("rateLimit"));
13426 }
13427 rate_limit__ =
13428 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13429 ;
13430 }
13431 GeneratedField::SecretRefs => {
13432 if secret_refs__.is_some() {
13433 return Err(serde::de::Error::duplicate_field("secretRefs"));
13434 }
13435 secret_refs__ = Some(
13436 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13437 );
13438 }
13439 }
13440 }
13441 Ok(StreamSource {
13442 source_id: source_id__.unwrap_or_default(),
13443 state_table: state_table__,
13444 row_id_index: row_id_index__,
13445 columns: columns__.unwrap_or_default(),
13446 with_properties: with_properties__.unwrap_or_default(),
13447 info: info__,
13448 source_name: source_name__.unwrap_or_default(),
13449 rate_limit: rate_limit__,
13450 secret_refs: secret_refs__.unwrap_or_default(),
13451 })
13452 }
13453 }
13454 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13455 }
13456}
13457impl serde::Serialize for SubscriptionUpstreamInfo {
13458 #[allow(deprecated)]
13459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13460 where
13461 S: serde::Serializer,
13462 {
13463 use serde::ser::SerializeStruct;
13464 let mut len = 0;
13465 if self.subscriber_id != 0 {
13466 len += 1;
13467 }
13468 if self.upstream_mv_table_id != 0 {
13469 len += 1;
13470 }
13471 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13472 if self.subscriber_id != 0 {
13473 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13474 }
13475 if self.upstream_mv_table_id != 0 {
13476 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13477 }
13478 struct_ser.end()
13479 }
13480}
13481impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13482 #[allow(deprecated)]
13483 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13484 where
13485 D: serde::Deserializer<'de>,
13486 {
13487 const FIELDS: &[&str] = &[
13488 "subscriber_id",
13489 "subscriberId",
13490 "upstream_mv_table_id",
13491 "upstreamMvTableId",
13492 ];
13493
13494 #[allow(clippy::enum_variant_names)]
13495 enum GeneratedField {
13496 SubscriberId,
13497 UpstreamMvTableId,
13498 }
13499 impl<'de> serde::Deserialize<'de> for GeneratedField {
13500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13501 where
13502 D: serde::Deserializer<'de>,
13503 {
13504 struct GeneratedVisitor;
13505
13506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13507 type Value = GeneratedField;
13508
13509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13510 write!(formatter, "expected one of: {:?}", &FIELDS)
13511 }
13512
13513 #[allow(unused_variables)]
13514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13515 where
13516 E: serde::de::Error,
13517 {
13518 match value {
13519 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
13520 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
13521 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13522 }
13523 }
13524 }
13525 deserializer.deserialize_identifier(GeneratedVisitor)
13526 }
13527 }
13528 struct GeneratedVisitor;
13529 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13530 type Value = SubscriptionUpstreamInfo;
13531
13532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13533 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
13534 }
13535
13536 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
13537 where
13538 V: serde::de::MapAccess<'de>,
13539 {
13540 let mut subscriber_id__ = None;
13541 let mut upstream_mv_table_id__ = None;
13542 while let Some(k) = map_.next_key()? {
13543 match k {
13544 GeneratedField::SubscriberId => {
13545 if subscriber_id__.is_some() {
13546 return Err(serde::de::Error::duplicate_field("subscriberId"));
13547 }
13548 subscriber_id__ =
13549 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13550 ;
13551 }
13552 GeneratedField::UpstreamMvTableId => {
13553 if upstream_mv_table_id__.is_some() {
13554 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13555 }
13556 upstream_mv_table_id__ =
13557 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13558 ;
13559 }
13560 }
13561 }
13562 Ok(SubscriptionUpstreamInfo {
13563 subscriber_id: subscriber_id__.unwrap_or_default(),
13564 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13565 })
13566 }
13567 }
13568 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13569 }
13570}
13571impl serde::Serialize for SyncLogStoreNode {
13572 #[allow(deprecated)]
13573 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13574 where
13575 S: serde::Serializer,
13576 {
13577 use serde::ser::SerializeStruct;
13578 let mut len = 0;
13579 if self.log_store_table.is_some() {
13580 len += 1;
13581 }
13582 if self.pause_duration_ms != 0 {
13583 len += 1;
13584 }
13585 if self.buffer_size != 0 {
13586 len += 1;
13587 }
13588 if self.aligned {
13589 len += 1;
13590 }
13591 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13592 if let Some(v) = self.log_store_table.as_ref() {
13593 struct_ser.serialize_field("logStoreTable", v)?;
13594 }
13595 if self.pause_duration_ms != 0 {
13596 struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13597 }
13598 if self.buffer_size != 0 {
13599 struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13600 }
13601 if self.aligned {
13602 struct_ser.serialize_field("aligned", &self.aligned)?;
13603 }
13604 struct_ser.end()
13605 }
13606}
13607impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13608 #[allow(deprecated)]
13609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13610 where
13611 D: serde::Deserializer<'de>,
13612 {
13613 const FIELDS: &[&str] = &[
13614 "log_store_table",
13615 "logStoreTable",
13616 "pause_duration_ms",
13617 "pauseDurationMs",
13618 "buffer_size",
13619 "bufferSize",
13620 "aligned",
13621 ];
13622
13623 #[allow(clippy::enum_variant_names)]
13624 enum GeneratedField {
13625 LogStoreTable,
13626 PauseDurationMs,
13627 BufferSize,
13628 Aligned,
13629 }
13630 impl<'de> serde::Deserialize<'de> for GeneratedField {
13631 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13632 where
13633 D: serde::Deserializer<'de>,
13634 {
13635 struct GeneratedVisitor;
13636
13637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13638 type Value = GeneratedField;
13639
13640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13641 write!(formatter, "expected one of: {:?}", &FIELDS)
13642 }
13643
13644 #[allow(unused_variables)]
13645 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13646 where
13647 E: serde::de::Error,
13648 {
13649 match value {
13650 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
13651 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
13652 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
13653 "aligned" => Ok(GeneratedField::Aligned),
13654 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13655 }
13656 }
13657 }
13658 deserializer.deserialize_identifier(GeneratedVisitor)
13659 }
13660 }
13661 struct GeneratedVisitor;
13662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13663 type Value = SyncLogStoreNode;
13664
13665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13666 formatter.write_str("struct stream_plan.SyncLogStoreNode")
13667 }
13668
13669 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
13670 where
13671 V: serde::de::MapAccess<'de>,
13672 {
13673 let mut log_store_table__ = None;
13674 let mut pause_duration_ms__ = None;
13675 let mut buffer_size__ = None;
13676 let mut aligned__ = None;
13677 while let Some(k) = map_.next_key()? {
13678 match k {
13679 GeneratedField::LogStoreTable => {
13680 if log_store_table__.is_some() {
13681 return Err(serde::de::Error::duplicate_field("logStoreTable"));
13682 }
13683 log_store_table__ = map_.next_value()?;
13684 }
13685 GeneratedField::PauseDurationMs => {
13686 if pause_duration_ms__.is_some() {
13687 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
13688 }
13689 pause_duration_ms__ =
13690 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13691 ;
13692 }
13693 GeneratedField::BufferSize => {
13694 if buffer_size__.is_some() {
13695 return Err(serde::de::Error::duplicate_field("bufferSize"));
13696 }
13697 buffer_size__ =
13698 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13699 ;
13700 }
13701 GeneratedField::Aligned => {
13702 if aligned__.is_some() {
13703 return Err(serde::de::Error::duplicate_field("aligned"));
13704 }
13705 aligned__ = Some(map_.next_value()?);
13706 }
13707 }
13708 }
13709 Ok(SyncLogStoreNode {
13710 log_store_table: log_store_table__,
13711 pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
13712 buffer_size: buffer_size__.unwrap_or_default(),
13713 aligned: aligned__.unwrap_or_default(),
13714 })
13715 }
13716 }
13717 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
13718 }
13719}
13720impl serde::Serialize for TemporalJoinNode {
13721 #[allow(deprecated)]
13722 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13723 where
13724 S: serde::Serializer,
13725 {
13726 use serde::ser::SerializeStruct;
13727 let mut len = 0;
13728 if self.join_type != 0 {
13729 len += 1;
13730 }
13731 if !self.left_key.is_empty() {
13732 len += 1;
13733 }
13734 if !self.right_key.is_empty() {
13735 len += 1;
13736 }
13737 if !self.null_safe.is_empty() {
13738 len += 1;
13739 }
13740 if self.condition.is_some() {
13741 len += 1;
13742 }
13743 if !self.output_indices.is_empty() {
13744 len += 1;
13745 }
13746 if self.table_desc.is_some() {
13747 len += 1;
13748 }
13749 if !self.table_output_indices.is_empty() {
13750 len += 1;
13751 }
13752 if self.memo_table.is_some() {
13753 len += 1;
13754 }
13755 if self.is_nested_loop {
13756 len += 1;
13757 }
13758 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
13759 if self.join_type != 0 {
13760 let v = super::plan_common::JoinType::try_from(self.join_type)
13761 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
13762 struct_ser.serialize_field("joinType", &v)?;
13763 }
13764 if !self.left_key.is_empty() {
13765 struct_ser.serialize_field("leftKey", &self.left_key)?;
13766 }
13767 if !self.right_key.is_empty() {
13768 struct_ser.serialize_field("rightKey", &self.right_key)?;
13769 }
13770 if !self.null_safe.is_empty() {
13771 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
13772 }
13773 if let Some(v) = self.condition.as_ref() {
13774 struct_ser.serialize_field("condition", v)?;
13775 }
13776 if !self.output_indices.is_empty() {
13777 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13778 }
13779 if let Some(v) = self.table_desc.as_ref() {
13780 struct_ser.serialize_field("tableDesc", v)?;
13781 }
13782 if !self.table_output_indices.is_empty() {
13783 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
13784 }
13785 if let Some(v) = self.memo_table.as_ref() {
13786 struct_ser.serialize_field("memoTable", v)?;
13787 }
13788 if self.is_nested_loop {
13789 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
13790 }
13791 struct_ser.end()
13792 }
13793}
13794impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
13795 #[allow(deprecated)]
13796 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13797 where
13798 D: serde::Deserializer<'de>,
13799 {
13800 const FIELDS: &[&str] = &[
13801 "join_type",
13802 "joinType",
13803 "left_key",
13804 "leftKey",
13805 "right_key",
13806 "rightKey",
13807 "null_safe",
13808 "nullSafe",
13809 "condition",
13810 "output_indices",
13811 "outputIndices",
13812 "table_desc",
13813 "tableDesc",
13814 "table_output_indices",
13815 "tableOutputIndices",
13816 "memo_table",
13817 "memoTable",
13818 "is_nested_loop",
13819 "isNestedLoop",
13820 ];
13821
13822 #[allow(clippy::enum_variant_names)]
13823 enum GeneratedField {
13824 JoinType,
13825 LeftKey,
13826 RightKey,
13827 NullSafe,
13828 Condition,
13829 OutputIndices,
13830 TableDesc,
13831 TableOutputIndices,
13832 MemoTable,
13833 IsNestedLoop,
13834 }
13835 impl<'de> serde::Deserialize<'de> for GeneratedField {
13836 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13837 where
13838 D: serde::Deserializer<'de>,
13839 {
13840 struct GeneratedVisitor;
13841
13842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13843 type Value = GeneratedField;
13844
13845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13846 write!(formatter, "expected one of: {:?}", &FIELDS)
13847 }
13848
13849 #[allow(unused_variables)]
13850 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13851 where
13852 E: serde::de::Error,
13853 {
13854 match value {
13855 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
13856 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
13857 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
13858 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
13859 "condition" => Ok(GeneratedField::Condition),
13860 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13861 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13862 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
13863 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
13864 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
13865 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13866 }
13867 }
13868 }
13869 deserializer.deserialize_identifier(GeneratedVisitor)
13870 }
13871 }
13872 struct GeneratedVisitor;
13873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13874 type Value = TemporalJoinNode;
13875
13876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13877 formatter.write_str("struct stream_plan.TemporalJoinNode")
13878 }
13879
13880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
13881 where
13882 V: serde::de::MapAccess<'de>,
13883 {
13884 let mut join_type__ = None;
13885 let mut left_key__ = None;
13886 let mut right_key__ = None;
13887 let mut null_safe__ = None;
13888 let mut condition__ = None;
13889 let mut output_indices__ = None;
13890 let mut table_desc__ = None;
13891 let mut table_output_indices__ = None;
13892 let mut memo_table__ = None;
13893 let mut is_nested_loop__ = None;
13894 while let Some(k) = map_.next_key()? {
13895 match k {
13896 GeneratedField::JoinType => {
13897 if join_type__.is_some() {
13898 return Err(serde::de::Error::duplicate_field("joinType"));
13899 }
13900 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
13901 }
13902 GeneratedField::LeftKey => {
13903 if left_key__.is_some() {
13904 return Err(serde::de::Error::duplicate_field("leftKey"));
13905 }
13906 left_key__ =
13907 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13908 .into_iter().map(|x| x.0).collect())
13909 ;
13910 }
13911 GeneratedField::RightKey => {
13912 if right_key__.is_some() {
13913 return Err(serde::de::Error::duplicate_field("rightKey"));
13914 }
13915 right_key__ =
13916 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13917 .into_iter().map(|x| x.0).collect())
13918 ;
13919 }
13920 GeneratedField::NullSafe => {
13921 if null_safe__.is_some() {
13922 return Err(serde::de::Error::duplicate_field("nullSafe"));
13923 }
13924 null_safe__ = Some(map_.next_value()?);
13925 }
13926 GeneratedField::Condition => {
13927 if condition__.is_some() {
13928 return Err(serde::de::Error::duplicate_field("condition"));
13929 }
13930 condition__ = map_.next_value()?;
13931 }
13932 GeneratedField::OutputIndices => {
13933 if output_indices__.is_some() {
13934 return Err(serde::de::Error::duplicate_field("outputIndices"));
13935 }
13936 output_indices__ =
13937 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13938 .into_iter().map(|x| x.0).collect())
13939 ;
13940 }
13941 GeneratedField::TableDesc => {
13942 if table_desc__.is_some() {
13943 return Err(serde::de::Error::duplicate_field("tableDesc"));
13944 }
13945 table_desc__ = map_.next_value()?;
13946 }
13947 GeneratedField::TableOutputIndices => {
13948 if table_output_indices__.is_some() {
13949 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
13950 }
13951 table_output_indices__ =
13952 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13953 .into_iter().map(|x| x.0).collect())
13954 ;
13955 }
13956 GeneratedField::MemoTable => {
13957 if memo_table__.is_some() {
13958 return Err(serde::de::Error::duplicate_field("memoTable"));
13959 }
13960 memo_table__ = map_.next_value()?;
13961 }
13962 GeneratedField::IsNestedLoop => {
13963 if is_nested_loop__.is_some() {
13964 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
13965 }
13966 is_nested_loop__ = Some(map_.next_value()?);
13967 }
13968 }
13969 }
13970 Ok(TemporalJoinNode {
13971 join_type: join_type__.unwrap_or_default(),
13972 left_key: left_key__.unwrap_or_default(),
13973 right_key: right_key__.unwrap_or_default(),
13974 null_safe: null_safe__.unwrap_or_default(),
13975 condition: condition__,
13976 output_indices: output_indices__.unwrap_or_default(),
13977 table_desc: table_desc__,
13978 table_output_indices: table_output_indices__.unwrap_or_default(),
13979 memo_table: memo_table__,
13980 is_nested_loop: is_nested_loop__.unwrap_or_default(),
13981 })
13982 }
13983 }
13984 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
13985 }
13986}
13987impl serde::Serialize for ThrottleMutation {
13988 #[allow(deprecated)]
13989 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13990 where
13991 S: serde::Serializer,
13992 {
13993 use serde::ser::SerializeStruct;
13994 let mut len = 0;
13995 if !self.actor_throttle.is_empty() {
13996 len += 1;
13997 }
13998 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
13999 if !self.actor_throttle.is_empty() {
14000 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
14001 }
14002 struct_ser.end()
14003 }
14004}
14005impl<'de> serde::Deserialize<'de> for ThrottleMutation {
14006 #[allow(deprecated)]
14007 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14008 where
14009 D: serde::Deserializer<'de>,
14010 {
14011 const FIELDS: &[&str] = &[
14012 "actor_throttle",
14013 "actorThrottle",
14014 ];
14015
14016 #[allow(clippy::enum_variant_names)]
14017 enum GeneratedField {
14018 ActorThrottle,
14019 }
14020 impl<'de> serde::Deserialize<'de> for GeneratedField {
14021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14022 where
14023 D: serde::Deserializer<'de>,
14024 {
14025 struct GeneratedVisitor;
14026
14027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14028 type Value = GeneratedField;
14029
14030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14031 write!(formatter, "expected one of: {:?}", &FIELDS)
14032 }
14033
14034 #[allow(unused_variables)]
14035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14036 where
14037 E: serde::de::Error,
14038 {
14039 match value {
14040 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
14041 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14042 }
14043 }
14044 }
14045 deserializer.deserialize_identifier(GeneratedVisitor)
14046 }
14047 }
14048 struct GeneratedVisitor;
14049 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14050 type Value = ThrottleMutation;
14051
14052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14053 formatter.write_str("struct stream_plan.ThrottleMutation")
14054 }
14055
14056 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
14057 where
14058 V: serde::de::MapAccess<'de>,
14059 {
14060 let mut actor_throttle__ = None;
14061 while let Some(k) = map_.next_key()? {
14062 match k {
14063 GeneratedField::ActorThrottle => {
14064 if actor_throttle__.is_some() {
14065 return Err(serde::de::Error::duplicate_field("actorThrottle"));
14066 }
14067 actor_throttle__ = Some(
14068 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14069 .into_iter().map(|(k,v)| (k.0, v)).collect()
14070 );
14071 }
14072 }
14073 }
14074 Ok(ThrottleMutation {
14075 actor_throttle: actor_throttle__.unwrap_or_default(),
14076 })
14077 }
14078 }
14079 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
14080 }
14081}
14082impl serde::Serialize for throttle_mutation::RateLimit {
14083 #[allow(deprecated)]
14084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14085 where
14086 S: serde::Serializer,
14087 {
14088 use serde::ser::SerializeStruct;
14089 let mut len = 0;
14090 if self.rate_limit.is_some() {
14091 len += 1;
14092 }
14093 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
14094 if let Some(v) = self.rate_limit.as_ref() {
14095 struct_ser.serialize_field("rateLimit", v)?;
14096 }
14097 struct_ser.end()
14098 }
14099}
14100impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
14101 #[allow(deprecated)]
14102 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14103 where
14104 D: serde::Deserializer<'de>,
14105 {
14106 const FIELDS: &[&str] = &[
14107 "rate_limit",
14108 "rateLimit",
14109 ];
14110
14111 #[allow(clippy::enum_variant_names)]
14112 enum GeneratedField {
14113 RateLimit,
14114 }
14115 impl<'de> serde::Deserialize<'de> for GeneratedField {
14116 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14117 where
14118 D: serde::Deserializer<'de>,
14119 {
14120 struct GeneratedVisitor;
14121
14122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14123 type Value = GeneratedField;
14124
14125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14126 write!(formatter, "expected one of: {:?}", &FIELDS)
14127 }
14128
14129 #[allow(unused_variables)]
14130 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14131 where
14132 E: serde::de::Error,
14133 {
14134 match value {
14135 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14136 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14137 }
14138 }
14139 }
14140 deserializer.deserialize_identifier(GeneratedVisitor)
14141 }
14142 }
14143 struct GeneratedVisitor;
14144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14145 type Value = throttle_mutation::RateLimit;
14146
14147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14148 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
14149 }
14150
14151 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
14152 where
14153 V: serde::de::MapAccess<'de>,
14154 {
14155 let mut rate_limit__ = None;
14156 while let Some(k) = map_.next_key()? {
14157 match k {
14158 GeneratedField::RateLimit => {
14159 if rate_limit__.is_some() {
14160 return Err(serde::de::Error::duplicate_field("rateLimit"));
14161 }
14162 rate_limit__ =
14163 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14164 ;
14165 }
14166 }
14167 }
14168 Ok(throttle_mutation::RateLimit {
14169 rate_limit: rate_limit__,
14170 })
14171 }
14172 }
14173 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
14174 }
14175}
14176impl serde::Serialize for TopNNode {
14177 #[allow(deprecated)]
14178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14179 where
14180 S: serde::Serializer,
14181 {
14182 use serde::ser::SerializeStruct;
14183 let mut len = 0;
14184 if self.limit != 0 {
14185 len += 1;
14186 }
14187 if self.offset != 0 {
14188 len += 1;
14189 }
14190 if self.table.is_some() {
14191 len += 1;
14192 }
14193 if !self.order_by.is_empty() {
14194 len += 1;
14195 }
14196 if self.with_ties {
14197 len += 1;
14198 }
14199 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
14200 if self.limit != 0 {
14201 #[allow(clippy::needless_borrow)]
14202 #[allow(clippy::needless_borrows_for_generic_args)]
14203 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
14204 }
14205 if self.offset != 0 {
14206 #[allow(clippy::needless_borrow)]
14207 #[allow(clippy::needless_borrows_for_generic_args)]
14208 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
14209 }
14210 if let Some(v) = self.table.as_ref() {
14211 struct_ser.serialize_field("table", v)?;
14212 }
14213 if !self.order_by.is_empty() {
14214 struct_ser.serialize_field("orderBy", &self.order_by)?;
14215 }
14216 if self.with_ties {
14217 struct_ser.serialize_field("withTies", &self.with_ties)?;
14218 }
14219 struct_ser.end()
14220 }
14221}
14222impl<'de> serde::Deserialize<'de> for TopNNode {
14223 #[allow(deprecated)]
14224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14225 where
14226 D: serde::Deserializer<'de>,
14227 {
14228 const FIELDS: &[&str] = &[
14229 "limit",
14230 "offset",
14231 "table",
14232 "order_by",
14233 "orderBy",
14234 "with_ties",
14235 "withTies",
14236 ];
14237
14238 #[allow(clippy::enum_variant_names)]
14239 enum GeneratedField {
14240 Limit,
14241 Offset,
14242 Table,
14243 OrderBy,
14244 WithTies,
14245 }
14246 impl<'de> serde::Deserialize<'de> for GeneratedField {
14247 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14248 where
14249 D: serde::Deserializer<'de>,
14250 {
14251 struct GeneratedVisitor;
14252
14253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14254 type Value = GeneratedField;
14255
14256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14257 write!(formatter, "expected one of: {:?}", &FIELDS)
14258 }
14259
14260 #[allow(unused_variables)]
14261 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14262 where
14263 E: serde::de::Error,
14264 {
14265 match value {
14266 "limit" => Ok(GeneratedField::Limit),
14267 "offset" => Ok(GeneratedField::Offset),
14268 "table" => Ok(GeneratedField::Table),
14269 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
14270 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
14271 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14272 }
14273 }
14274 }
14275 deserializer.deserialize_identifier(GeneratedVisitor)
14276 }
14277 }
14278 struct GeneratedVisitor;
14279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14280 type Value = TopNNode;
14281
14282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14283 formatter.write_str("struct stream_plan.TopNNode")
14284 }
14285
14286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
14287 where
14288 V: serde::de::MapAccess<'de>,
14289 {
14290 let mut limit__ = None;
14291 let mut offset__ = None;
14292 let mut table__ = None;
14293 let mut order_by__ = None;
14294 let mut with_ties__ = None;
14295 while let Some(k) = map_.next_key()? {
14296 match k {
14297 GeneratedField::Limit => {
14298 if limit__.is_some() {
14299 return Err(serde::de::Error::duplicate_field("limit"));
14300 }
14301 limit__ =
14302 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14303 ;
14304 }
14305 GeneratedField::Offset => {
14306 if offset__.is_some() {
14307 return Err(serde::de::Error::duplicate_field("offset"));
14308 }
14309 offset__ =
14310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14311 ;
14312 }
14313 GeneratedField::Table => {
14314 if table__.is_some() {
14315 return Err(serde::de::Error::duplicate_field("table"));
14316 }
14317 table__ = map_.next_value()?;
14318 }
14319 GeneratedField::OrderBy => {
14320 if order_by__.is_some() {
14321 return Err(serde::de::Error::duplicate_field("orderBy"));
14322 }
14323 order_by__ = Some(map_.next_value()?);
14324 }
14325 GeneratedField::WithTies => {
14326 if with_ties__.is_some() {
14327 return Err(serde::de::Error::duplicate_field("withTies"));
14328 }
14329 with_ties__ = Some(map_.next_value()?);
14330 }
14331 }
14332 }
14333 Ok(TopNNode {
14334 limit: limit__.unwrap_or_default(),
14335 offset: offset__.unwrap_or_default(),
14336 table: table__,
14337 order_by: order_by__.unwrap_or_default(),
14338 with_ties: with_ties__.unwrap_or_default(),
14339 })
14340 }
14341 }
14342 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
14343 }
14344}
14345impl serde::Serialize for UnionNode {
14346 #[allow(deprecated)]
14347 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14348 where
14349 S: serde::Serializer,
14350 {
14351 use serde::ser::SerializeStruct;
14352 let len = 0;
14353 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
14354 struct_ser.end()
14355 }
14356}
14357impl<'de> serde::Deserialize<'de> for UnionNode {
14358 #[allow(deprecated)]
14359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14360 where
14361 D: serde::Deserializer<'de>,
14362 {
14363 const FIELDS: &[&str] = &[
14364 ];
14365
14366 #[allow(clippy::enum_variant_names)]
14367 enum GeneratedField {
14368 }
14369 impl<'de> serde::Deserialize<'de> for GeneratedField {
14370 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14371 where
14372 D: serde::Deserializer<'de>,
14373 {
14374 struct GeneratedVisitor;
14375
14376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14377 type Value = GeneratedField;
14378
14379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14380 write!(formatter, "expected one of: {:?}", &FIELDS)
14381 }
14382
14383 #[allow(unused_variables)]
14384 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14385 where
14386 E: serde::de::Error,
14387 {
14388 Err(serde::de::Error::unknown_field(value, FIELDS))
14389 }
14390 }
14391 deserializer.deserialize_identifier(GeneratedVisitor)
14392 }
14393 }
14394 struct GeneratedVisitor;
14395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14396 type Value = UnionNode;
14397
14398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14399 formatter.write_str("struct stream_plan.UnionNode")
14400 }
14401
14402 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
14403 where
14404 V: serde::de::MapAccess<'de>,
14405 {
14406 while map_.next_key::<GeneratedField>()?.is_some() {
14407 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14408 }
14409 Ok(UnionNode {
14410 })
14411 }
14412 }
14413 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
14414 }
14415}
14416impl serde::Serialize for UpdateMutation {
14417 #[allow(deprecated)]
14418 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14419 where
14420 S: serde::Serializer,
14421 {
14422 use serde::ser::SerializeStruct;
14423 let mut len = 0;
14424 if !self.dispatcher_update.is_empty() {
14425 len += 1;
14426 }
14427 if !self.merge_update.is_empty() {
14428 len += 1;
14429 }
14430 if !self.actor_vnode_bitmap_update.is_empty() {
14431 len += 1;
14432 }
14433 if !self.dropped_actors.is_empty() {
14434 len += 1;
14435 }
14436 if !self.actor_splits.is_empty() {
14437 len += 1;
14438 }
14439 if !self.actor_new_dispatchers.is_empty() {
14440 len += 1;
14441 }
14442 if !self.actor_cdc_table_snapshot_splits.is_empty() {
14443 len += 1;
14444 }
14445 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
14446 if !self.dispatcher_update.is_empty() {
14447 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14448 }
14449 if !self.merge_update.is_empty() {
14450 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14451 }
14452 if !self.actor_vnode_bitmap_update.is_empty() {
14453 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14454 }
14455 if !self.dropped_actors.is_empty() {
14456 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14457 }
14458 if !self.actor_splits.is_empty() {
14459 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14460 }
14461 if !self.actor_new_dispatchers.is_empty() {
14462 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14463 }
14464 if !self.actor_cdc_table_snapshot_splits.is_empty() {
14465 struct_ser.serialize_field("actorCdcTableSnapshotSplits", &self.actor_cdc_table_snapshot_splits)?;
14466 }
14467 struct_ser.end()
14468 }
14469}
14470impl<'de> serde::Deserialize<'de> for UpdateMutation {
14471 #[allow(deprecated)]
14472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14473 where
14474 D: serde::Deserializer<'de>,
14475 {
14476 const FIELDS: &[&str] = &[
14477 "dispatcher_update",
14478 "dispatcherUpdate",
14479 "merge_update",
14480 "mergeUpdate",
14481 "actor_vnode_bitmap_update",
14482 "actorVnodeBitmapUpdate",
14483 "dropped_actors",
14484 "droppedActors",
14485 "actor_splits",
14486 "actorSplits",
14487 "actor_new_dispatchers",
14488 "actorNewDispatchers",
14489 "actor_cdc_table_snapshot_splits",
14490 "actorCdcTableSnapshotSplits",
14491 ];
14492
14493 #[allow(clippy::enum_variant_names)]
14494 enum GeneratedField {
14495 DispatcherUpdate,
14496 MergeUpdate,
14497 ActorVnodeBitmapUpdate,
14498 DroppedActors,
14499 ActorSplits,
14500 ActorNewDispatchers,
14501 ActorCdcTableSnapshotSplits,
14502 }
14503 impl<'de> serde::Deserialize<'de> for GeneratedField {
14504 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14505 where
14506 D: serde::Deserializer<'de>,
14507 {
14508 struct GeneratedVisitor;
14509
14510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14511 type Value = GeneratedField;
14512
14513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14514 write!(formatter, "expected one of: {:?}", &FIELDS)
14515 }
14516
14517 #[allow(unused_variables)]
14518 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14519 where
14520 E: serde::de::Error,
14521 {
14522 match value {
14523 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
14524 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
14525 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
14526 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
14527 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14528 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
14529 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
14530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14531 }
14532 }
14533 }
14534 deserializer.deserialize_identifier(GeneratedVisitor)
14535 }
14536 }
14537 struct GeneratedVisitor;
14538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14539 type Value = UpdateMutation;
14540
14541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14542 formatter.write_str("struct stream_plan.UpdateMutation")
14543 }
14544
14545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
14546 where
14547 V: serde::de::MapAccess<'de>,
14548 {
14549 let mut dispatcher_update__ = None;
14550 let mut merge_update__ = None;
14551 let mut actor_vnode_bitmap_update__ = None;
14552 let mut dropped_actors__ = None;
14553 let mut actor_splits__ = None;
14554 let mut actor_new_dispatchers__ = None;
14555 let mut actor_cdc_table_snapshot_splits__ = None;
14556 while let Some(k) = map_.next_key()? {
14557 match k {
14558 GeneratedField::DispatcherUpdate => {
14559 if dispatcher_update__.is_some() {
14560 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
14561 }
14562 dispatcher_update__ = Some(map_.next_value()?);
14563 }
14564 GeneratedField::MergeUpdate => {
14565 if merge_update__.is_some() {
14566 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
14567 }
14568 merge_update__ = Some(map_.next_value()?);
14569 }
14570 GeneratedField::ActorVnodeBitmapUpdate => {
14571 if actor_vnode_bitmap_update__.is_some() {
14572 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
14573 }
14574 actor_vnode_bitmap_update__ = Some(
14575 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14576 .into_iter().map(|(k,v)| (k.0, v)).collect()
14577 );
14578 }
14579 GeneratedField::DroppedActors => {
14580 if dropped_actors__.is_some() {
14581 return Err(serde::de::Error::duplicate_field("droppedActors"));
14582 }
14583 dropped_actors__ =
14584 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14585 .into_iter().map(|x| x.0).collect())
14586 ;
14587 }
14588 GeneratedField::ActorSplits => {
14589 if actor_splits__.is_some() {
14590 return Err(serde::de::Error::duplicate_field("actorSplits"));
14591 }
14592 actor_splits__ = Some(
14593 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14594 .into_iter().map(|(k,v)| (k.0, v)).collect()
14595 );
14596 }
14597 GeneratedField::ActorNewDispatchers => {
14598 if actor_new_dispatchers__.is_some() {
14599 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14600 }
14601 actor_new_dispatchers__ = Some(
14602 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14603 .into_iter().map(|(k,v)| (k.0, v)).collect()
14604 );
14605 }
14606 GeneratedField::ActorCdcTableSnapshotSplits => {
14607 if actor_cdc_table_snapshot_splits__.is_some() {
14608 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
14609 }
14610 actor_cdc_table_snapshot_splits__ = Some(
14611 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14612 .into_iter().map(|(k,v)| (k.0, v)).collect()
14613 );
14614 }
14615 }
14616 }
14617 Ok(UpdateMutation {
14618 dispatcher_update: dispatcher_update__.unwrap_or_default(),
14619 merge_update: merge_update__.unwrap_or_default(),
14620 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
14621 dropped_actors: dropped_actors__.unwrap_or_default(),
14622 actor_splits: actor_splits__.unwrap_or_default(),
14623 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
14624 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__.unwrap_or_default(),
14625 })
14626 }
14627 }
14628 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
14629 }
14630}
14631impl serde::Serialize for update_mutation::DispatcherUpdate {
14632 #[allow(deprecated)]
14633 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14634 where
14635 S: serde::Serializer,
14636 {
14637 use serde::ser::SerializeStruct;
14638 let mut len = 0;
14639 if self.actor_id != 0 {
14640 len += 1;
14641 }
14642 if self.dispatcher_id != 0 {
14643 len += 1;
14644 }
14645 if self.hash_mapping.is_some() {
14646 len += 1;
14647 }
14648 if !self.added_downstream_actor_id.is_empty() {
14649 len += 1;
14650 }
14651 if !self.removed_downstream_actor_id.is_empty() {
14652 len += 1;
14653 }
14654 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
14655 if self.actor_id != 0 {
14656 struct_ser.serialize_field("actorId", &self.actor_id)?;
14657 }
14658 if self.dispatcher_id != 0 {
14659 #[allow(clippy::needless_borrow)]
14660 #[allow(clippy::needless_borrows_for_generic_args)]
14661 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
14662 }
14663 if let Some(v) = self.hash_mapping.as_ref() {
14664 struct_ser.serialize_field("hashMapping", v)?;
14665 }
14666 if !self.added_downstream_actor_id.is_empty() {
14667 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
14668 }
14669 if !self.removed_downstream_actor_id.is_empty() {
14670 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
14671 }
14672 struct_ser.end()
14673 }
14674}
14675impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
14676 #[allow(deprecated)]
14677 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14678 where
14679 D: serde::Deserializer<'de>,
14680 {
14681 const FIELDS: &[&str] = &[
14682 "actor_id",
14683 "actorId",
14684 "dispatcher_id",
14685 "dispatcherId",
14686 "hash_mapping",
14687 "hashMapping",
14688 "added_downstream_actor_id",
14689 "addedDownstreamActorId",
14690 "removed_downstream_actor_id",
14691 "removedDownstreamActorId",
14692 ];
14693
14694 #[allow(clippy::enum_variant_names)]
14695 enum GeneratedField {
14696 ActorId,
14697 DispatcherId,
14698 HashMapping,
14699 AddedDownstreamActorId,
14700 RemovedDownstreamActorId,
14701 }
14702 impl<'de> serde::Deserialize<'de> for GeneratedField {
14703 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14704 where
14705 D: serde::Deserializer<'de>,
14706 {
14707 struct GeneratedVisitor;
14708
14709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14710 type Value = GeneratedField;
14711
14712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14713 write!(formatter, "expected one of: {:?}", &FIELDS)
14714 }
14715
14716 #[allow(unused_variables)]
14717 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14718 where
14719 E: serde::de::Error,
14720 {
14721 match value {
14722 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14723 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
14724 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
14725 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
14726 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
14727 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14728 }
14729 }
14730 }
14731 deserializer.deserialize_identifier(GeneratedVisitor)
14732 }
14733 }
14734 struct GeneratedVisitor;
14735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14736 type Value = update_mutation::DispatcherUpdate;
14737
14738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14739 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
14740 }
14741
14742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
14743 where
14744 V: serde::de::MapAccess<'de>,
14745 {
14746 let mut actor_id__ = None;
14747 let mut dispatcher_id__ = None;
14748 let mut hash_mapping__ = None;
14749 let mut added_downstream_actor_id__ = None;
14750 let mut removed_downstream_actor_id__ = None;
14751 while let Some(k) = map_.next_key()? {
14752 match k {
14753 GeneratedField::ActorId => {
14754 if actor_id__.is_some() {
14755 return Err(serde::de::Error::duplicate_field("actorId"));
14756 }
14757 actor_id__ =
14758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14759 ;
14760 }
14761 GeneratedField::DispatcherId => {
14762 if dispatcher_id__.is_some() {
14763 return Err(serde::de::Error::duplicate_field("dispatcherId"));
14764 }
14765 dispatcher_id__ =
14766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14767 ;
14768 }
14769 GeneratedField::HashMapping => {
14770 if hash_mapping__.is_some() {
14771 return Err(serde::de::Error::duplicate_field("hashMapping"));
14772 }
14773 hash_mapping__ = map_.next_value()?;
14774 }
14775 GeneratedField::AddedDownstreamActorId => {
14776 if added_downstream_actor_id__.is_some() {
14777 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
14778 }
14779 added_downstream_actor_id__ =
14780 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14781 .into_iter().map(|x| x.0).collect())
14782 ;
14783 }
14784 GeneratedField::RemovedDownstreamActorId => {
14785 if removed_downstream_actor_id__.is_some() {
14786 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
14787 }
14788 removed_downstream_actor_id__ =
14789 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14790 .into_iter().map(|x| x.0).collect())
14791 ;
14792 }
14793 }
14794 }
14795 Ok(update_mutation::DispatcherUpdate {
14796 actor_id: actor_id__.unwrap_or_default(),
14797 dispatcher_id: dispatcher_id__.unwrap_or_default(),
14798 hash_mapping: hash_mapping__,
14799 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
14800 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
14801 })
14802 }
14803 }
14804 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
14805 }
14806}
14807impl serde::Serialize for update_mutation::MergeUpdate {
14808 #[allow(deprecated)]
14809 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14810 where
14811 S: serde::Serializer,
14812 {
14813 use serde::ser::SerializeStruct;
14814 let mut len = 0;
14815 if self.actor_id != 0 {
14816 len += 1;
14817 }
14818 if self.upstream_fragment_id != 0 {
14819 len += 1;
14820 }
14821 if self.new_upstream_fragment_id.is_some() {
14822 len += 1;
14823 }
14824 if !self.added_upstream_actors.is_empty() {
14825 len += 1;
14826 }
14827 if !self.removed_upstream_actor_id.is_empty() {
14828 len += 1;
14829 }
14830 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
14831 if self.actor_id != 0 {
14832 struct_ser.serialize_field("actorId", &self.actor_id)?;
14833 }
14834 if self.upstream_fragment_id != 0 {
14835 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
14836 }
14837 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
14838 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
14839 }
14840 if !self.added_upstream_actors.is_empty() {
14841 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
14842 }
14843 if !self.removed_upstream_actor_id.is_empty() {
14844 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
14845 }
14846 struct_ser.end()
14847 }
14848}
14849impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
14850 #[allow(deprecated)]
14851 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14852 where
14853 D: serde::Deserializer<'de>,
14854 {
14855 const FIELDS: &[&str] = &[
14856 "actor_id",
14857 "actorId",
14858 "upstream_fragment_id",
14859 "upstreamFragmentId",
14860 "new_upstream_fragment_id",
14861 "newUpstreamFragmentId",
14862 "added_upstream_actors",
14863 "addedUpstreamActors",
14864 "removed_upstream_actor_id",
14865 "removedUpstreamActorId",
14866 ];
14867
14868 #[allow(clippy::enum_variant_names)]
14869 enum GeneratedField {
14870 ActorId,
14871 UpstreamFragmentId,
14872 NewUpstreamFragmentId,
14873 AddedUpstreamActors,
14874 RemovedUpstreamActorId,
14875 }
14876 impl<'de> serde::Deserialize<'de> for GeneratedField {
14877 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14878 where
14879 D: serde::Deserializer<'de>,
14880 {
14881 struct GeneratedVisitor;
14882
14883 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14884 type Value = GeneratedField;
14885
14886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14887 write!(formatter, "expected one of: {:?}", &FIELDS)
14888 }
14889
14890 #[allow(unused_variables)]
14891 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14892 where
14893 E: serde::de::Error,
14894 {
14895 match value {
14896 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14897 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
14898 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
14899 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
14900 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
14901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14902 }
14903 }
14904 }
14905 deserializer.deserialize_identifier(GeneratedVisitor)
14906 }
14907 }
14908 struct GeneratedVisitor;
14909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14910 type Value = update_mutation::MergeUpdate;
14911
14912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14913 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
14914 }
14915
14916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
14917 where
14918 V: serde::de::MapAccess<'de>,
14919 {
14920 let mut actor_id__ = None;
14921 let mut upstream_fragment_id__ = None;
14922 let mut new_upstream_fragment_id__ = None;
14923 let mut added_upstream_actors__ = None;
14924 let mut removed_upstream_actor_id__ = None;
14925 while let Some(k) = map_.next_key()? {
14926 match k {
14927 GeneratedField::ActorId => {
14928 if actor_id__.is_some() {
14929 return Err(serde::de::Error::duplicate_field("actorId"));
14930 }
14931 actor_id__ =
14932 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14933 ;
14934 }
14935 GeneratedField::UpstreamFragmentId => {
14936 if upstream_fragment_id__.is_some() {
14937 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
14938 }
14939 upstream_fragment_id__ =
14940 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14941 ;
14942 }
14943 GeneratedField::NewUpstreamFragmentId => {
14944 if new_upstream_fragment_id__.is_some() {
14945 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
14946 }
14947 new_upstream_fragment_id__ =
14948 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14949 ;
14950 }
14951 GeneratedField::AddedUpstreamActors => {
14952 if added_upstream_actors__.is_some() {
14953 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
14954 }
14955 added_upstream_actors__ = Some(map_.next_value()?);
14956 }
14957 GeneratedField::RemovedUpstreamActorId => {
14958 if removed_upstream_actor_id__.is_some() {
14959 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
14960 }
14961 removed_upstream_actor_id__ =
14962 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14963 .into_iter().map(|x| x.0).collect())
14964 ;
14965 }
14966 }
14967 }
14968 Ok(update_mutation::MergeUpdate {
14969 actor_id: actor_id__.unwrap_or_default(),
14970 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
14971 new_upstream_fragment_id: new_upstream_fragment_id__,
14972 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
14973 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
14974 })
14975 }
14976 }
14977 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
14978 }
14979}
14980impl serde::Serialize for ValuesNode {
14981 #[allow(deprecated)]
14982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14983 where
14984 S: serde::Serializer,
14985 {
14986 use serde::ser::SerializeStruct;
14987 let mut len = 0;
14988 if !self.tuples.is_empty() {
14989 len += 1;
14990 }
14991 if !self.fields.is_empty() {
14992 len += 1;
14993 }
14994 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
14995 if !self.tuples.is_empty() {
14996 struct_ser.serialize_field("tuples", &self.tuples)?;
14997 }
14998 if !self.fields.is_empty() {
14999 struct_ser.serialize_field("fields", &self.fields)?;
15000 }
15001 struct_ser.end()
15002 }
15003}
15004impl<'de> serde::Deserialize<'de> for ValuesNode {
15005 #[allow(deprecated)]
15006 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15007 where
15008 D: serde::Deserializer<'de>,
15009 {
15010 const FIELDS: &[&str] = &[
15011 "tuples",
15012 "fields",
15013 ];
15014
15015 #[allow(clippy::enum_variant_names)]
15016 enum GeneratedField {
15017 Tuples,
15018 Fields,
15019 }
15020 impl<'de> serde::Deserialize<'de> for GeneratedField {
15021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15022 where
15023 D: serde::Deserializer<'de>,
15024 {
15025 struct GeneratedVisitor;
15026
15027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15028 type Value = GeneratedField;
15029
15030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15031 write!(formatter, "expected one of: {:?}", &FIELDS)
15032 }
15033
15034 #[allow(unused_variables)]
15035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15036 where
15037 E: serde::de::Error,
15038 {
15039 match value {
15040 "tuples" => Ok(GeneratedField::Tuples),
15041 "fields" => Ok(GeneratedField::Fields),
15042 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15043 }
15044 }
15045 }
15046 deserializer.deserialize_identifier(GeneratedVisitor)
15047 }
15048 }
15049 struct GeneratedVisitor;
15050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15051 type Value = ValuesNode;
15052
15053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15054 formatter.write_str("struct stream_plan.ValuesNode")
15055 }
15056
15057 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
15058 where
15059 V: serde::de::MapAccess<'de>,
15060 {
15061 let mut tuples__ = None;
15062 let mut fields__ = None;
15063 while let Some(k) = map_.next_key()? {
15064 match k {
15065 GeneratedField::Tuples => {
15066 if tuples__.is_some() {
15067 return Err(serde::de::Error::duplicate_field("tuples"));
15068 }
15069 tuples__ = Some(map_.next_value()?);
15070 }
15071 GeneratedField::Fields => {
15072 if fields__.is_some() {
15073 return Err(serde::de::Error::duplicate_field("fields"));
15074 }
15075 fields__ = Some(map_.next_value()?);
15076 }
15077 }
15078 }
15079 Ok(ValuesNode {
15080 tuples: tuples__.unwrap_or_default(),
15081 fields: fields__.unwrap_or_default(),
15082 })
15083 }
15084 }
15085 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
15086 }
15087}
15088impl serde::Serialize for values_node::ExprTuple {
15089 #[allow(deprecated)]
15090 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15091 where
15092 S: serde::Serializer,
15093 {
15094 use serde::ser::SerializeStruct;
15095 let mut len = 0;
15096 if !self.cells.is_empty() {
15097 len += 1;
15098 }
15099 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
15100 if !self.cells.is_empty() {
15101 struct_ser.serialize_field("cells", &self.cells)?;
15102 }
15103 struct_ser.end()
15104 }
15105}
15106impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
15107 #[allow(deprecated)]
15108 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15109 where
15110 D: serde::Deserializer<'de>,
15111 {
15112 const FIELDS: &[&str] = &[
15113 "cells",
15114 ];
15115
15116 #[allow(clippy::enum_variant_names)]
15117 enum GeneratedField {
15118 Cells,
15119 }
15120 impl<'de> serde::Deserialize<'de> for GeneratedField {
15121 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15122 where
15123 D: serde::Deserializer<'de>,
15124 {
15125 struct GeneratedVisitor;
15126
15127 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15128 type Value = GeneratedField;
15129
15130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15131 write!(formatter, "expected one of: {:?}", &FIELDS)
15132 }
15133
15134 #[allow(unused_variables)]
15135 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15136 where
15137 E: serde::de::Error,
15138 {
15139 match value {
15140 "cells" => Ok(GeneratedField::Cells),
15141 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15142 }
15143 }
15144 }
15145 deserializer.deserialize_identifier(GeneratedVisitor)
15146 }
15147 }
15148 struct GeneratedVisitor;
15149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15150 type Value = values_node::ExprTuple;
15151
15152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15153 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
15154 }
15155
15156 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
15157 where
15158 V: serde::de::MapAccess<'de>,
15159 {
15160 let mut cells__ = None;
15161 while let Some(k) = map_.next_key()? {
15162 match k {
15163 GeneratedField::Cells => {
15164 if cells__.is_some() {
15165 return Err(serde::de::Error::duplicate_field("cells"));
15166 }
15167 cells__ = Some(map_.next_value()?);
15168 }
15169 }
15170 }
15171 Ok(values_node::ExprTuple {
15172 cells: cells__.unwrap_or_default(),
15173 })
15174 }
15175 }
15176 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
15177 }
15178}
15179impl serde::Serialize for VectorIndexWriteNode {
15180 #[allow(deprecated)]
15181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15182 where
15183 S: serde::Serializer,
15184 {
15185 use serde::ser::SerializeStruct;
15186 let mut len = 0;
15187 if self.table.is_some() {
15188 len += 1;
15189 }
15190 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
15191 if let Some(v) = self.table.as_ref() {
15192 struct_ser.serialize_field("table", v)?;
15193 }
15194 struct_ser.end()
15195 }
15196}
15197impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
15198 #[allow(deprecated)]
15199 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15200 where
15201 D: serde::Deserializer<'de>,
15202 {
15203 const FIELDS: &[&str] = &[
15204 "table",
15205 ];
15206
15207 #[allow(clippy::enum_variant_names)]
15208 enum GeneratedField {
15209 Table,
15210 }
15211 impl<'de> serde::Deserialize<'de> for GeneratedField {
15212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15213 where
15214 D: serde::Deserializer<'de>,
15215 {
15216 struct GeneratedVisitor;
15217
15218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15219 type Value = GeneratedField;
15220
15221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15222 write!(formatter, "expected one of: {:?}", &FIELDS)
15223 }
15224
15225 #[allow(unused_variables)]
15226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15227 where
15228 E: serde::de::Error,
15229 {
15230 match value {
15231 "table" => Ok(GeneratedField::Table),
15232 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15233 }
15234 }
15235 }
15236 deserializer.deserialize_identifier(GeneratedVisitor)
15237 }
15238 }
15239 struct GeneratedVisitor;
15240 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15241 type Value = VectorIndexWriteNode;
15242
15243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15244 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
15245 }
15246
15247 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
15248 where
15249 V: serde::de::MapAccess<'de>,
15250 {
15251 let mut table__ = None;
15252 while let Some(k) = map_.next_key()? {
15253 match k {
15254 GeneratedField::Table => {
15255 if table__.is_some() {
15256 return Err(serde::de::Error::duplicate_field("table"));
15257 }
15258 table__ = map_.next_value()?;
15259 }
15260 }
15261 }
15262 Ok(VectorIndexWriteNode {
15263 table: table__,
15264 })
15265 }
15266 }
15267 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
15268 }
15269}
15270impl serde::Serialize for Watermark {
15271 #[allow(deprecated)]
15272 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15273 where
15274 S: serde::Serializer,
15275 {
15276 use serde::ser::SerializeStruct;
15277 let mut len = 0;
15278 if self.column.is_some() {
15279 len += 1;
15280 }
15281 if self.val.is_some() {
15282 len += 1;
15283 }
15284 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
15285 if let Some(v) = self.column.as_ref() {
15286 struct_ser.serialize_field("column", v)?;
15287 }
15288 if let Some(v) = self.val.as_ref() {
15289 struct_ser.serialize_field("val", v)?;
15290 }
15291 struct_ser.end()
15292 }
15293}
15294impl<'de> serde::Deserialize<'de> for Watermark {
15295 #[allow(deprecated)]
15296 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15297 where
15298 D: serde::Deserializer<'de>,
15299 {
15300 const FIELDS: &[&str] = &[
15301 "column",
15302 "val",
15303 ];
15304
15305 #[allow(clippy::enum_variant_names)]
15306 enum GeneratedField {
15307 Column,
15308 Val,
15309 }
15310 impl<'de> serde::Deserialize<'de> for GeneratedField {
15311 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15312 where
15313 D: serde::Deserializer<'de>,
15314 {
15315 struct GeneratedVisitor;
15316
15317 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15318 type Value = GeneratedField;
15319
15320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15321 write!(formatter, "expected one of: {:?}", &FIELDS)
15322 }
15323
15324 #[allow(unused_variables)]
15325 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15326 where
15327 E: serde::de::Error,
15328 {
15329 match value {
15330 "column" => Ok(GeneratedField::Column),
15331 "val" => Ok(GeneratedField::Val),
15332 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15333 }
15334 }
15335 }
15336 deserializer.deserialize_identifier(GeneratedVisitor)
15337 }
15338 }
15339 struct GeneratedVisitor;
15340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15341 type Value = Watermark;
15342
15343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15344 formatter.write_str("struct stream_plan.Watermark")
15345 }
15346
15347 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
15348 where
15349 V: serde::de::MapAccess<'de>,
15350 {
15351 let mut column__ = None;
15352 let mut val__ = None;
15353 while let Some(k) = map_.next_key()? {
15354 match k {
15355 GeneratedField::Column => {
15356 if column__.is_some() {
15357 return Err(serde::de::Error::duplicate_field("column"));
15358 }
15359 column__ = map_.next_value()?;
15360 }
15361 GeneratedField::Val => {
15362 if val__.is_some() {
15363 return Err(serde::de::Error::duplicate_field("val"));
15364 }
15365 val__ = map_.next_value()?;
15366 }
15367 }
15368 }
15369 Ok(Watermark {
15370 column: column__,
15371 val: val__,
15372 })
15373 }
15374 }
15375 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
15376 }
15377}
15378impl serde::Serialize for WatermarkFilterNode {
15379 #[allow(deprecated)]
15380 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15381 where
15382 S: serde::Serializer,
15383 {
15384 use serde::ser::SerializeStruct;
15385 let mut len = 0;
15386 if !self.watermark_descs.is_empty() {
15387 len += 1;
15388 }
15389 if !self.tables.is_empty() {
15390 len += 1;
15391 }
15392 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
15393 if !self.watermark_descs.is_empty() {
15394 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
15395 }
15396 if !self.tables.is_empty() {
15397 struct_ser.serialize_field("tables", &self.tables)?;
15398 }
15399 struct_ser.end()
15400 }
15401}
15402impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
15403 #[allow(deprecated)]
15404 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15405 where
15406 D: serde::Deserializer<'de>,
15407 {
15408 const FIELDS: &[&str] = &[
15409 "watermark_descs",
15410 "watermarkDescs",
15411 "tables",
15412 ];
15413
15414 #[allow(clippy::enum_variant_names)]
15415 enum GeneratedField {
15416 WatermarkDescs,
15417 Tables,
15418 }
15419 impl<'de> serde::Deserialize<'de> for GeneratedField {
15420 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15421 where
15422 D: serde::Deserializer<'de>,
15423 {
15424 struct GeneratedVisitor;
15425
15426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15427 type Value = GeneratedField;
15428
15429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15430 write!(formatter, "expected one of: {:?}", &FIELDS)
15431 }
15432
15433 #[allow(unused_variables)]
15434 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15435 where
15436 E: serde::de::Error,
15437 {
15438 match value {
15439 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
15440 "tables" => Ok(GeneratedField::Tables),
15441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15442 }
15443 }
15444 }
15445 deserializer.deserialize_identifier(GeneratedVisitor)
15446 }
15447 }
15448 struct GeneratedVisitor;
15449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15450 type Value = WatermarkFilterNode;
15451
15452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15453 formatter.write_str("struct stream_plan.WatermarkFilterNode")
15454 }
15455
15456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
15457 where
15458 V: serde::de::MapAccess<'de>,
15459 {
15460 let mut watermark_descs__ = None;
15461 let mut tables__ = None;
15462 while let Some(k) = map_.next_key()? {
15463 match k {
15464 GeneratedField::WatermarkDescs => {
15465 if watermark_descs__.is_some() {
15466 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
15467 }
15468 watermark_descs__ = Some(map_.next_value()?);
15469 }
15470 GeneratedField::Tables => {
15471 if tables__.is_some() {
15472 return Err(serde::de::Error::duplicate_field("tables"));
15473 }
15474 tables__ = Some(map_.next_value()?);
15475 }
15476 }
15477 }
15478 Ok(WatermarkFilterNode {
15479 watermark_descs: watermark_descs__.unwrap_or_default(),
15480 tables: tables__.unwrap_or_default(),
15481 })
15482 }
15483 }
15484 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
15485 }
15486}