1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::stream_plan::*;
4impl serde::Serialize for ActorMapping {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if !self.original_indices.is_empty() {
13 len += 1;
14 }
15 if !self.data.is_empty() {
16 len += 1;
17 }
18 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
19 if !self.original_indices.is_empty() {
20 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
21 }
22 if !self.data.is_empty() {
23 struct_ser.serialize_field("data", &self.data)?;
24 }
25 struct_ser.end()
26 }
27}
28impl<'de> serde::Deserialize<'de> for ActorMapping {
29 #[allow(deprecated)]
30 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
31 where
32 D: serde::Deserializer<'de>,
33 {
34 const FIELDS: &[&str] = &[
35 "original_indices",
36 "originalIndices",
37 "data",
38 ];
39
40 #[allow(clippy::enum_variant_names)]
41 enum GeneratedField {
42 OriginalIndices,
43 Data,
44 }
45 impl<'de> serde::Deserialize<'de> for GeneratedField {
46 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
47 where
48 D: serde::Deserializer<'de>,
49 {
50 struct GeneratedVisitor;
51
52 impl serde::de::Visitor<'_> for GeneratedVisitor {
53 type Value = GeneratedField;
54
55 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 write!(formatter, "expected one of: {:?}", &FIELDS)
57 }
58
59 #[allow(unused_variables)]
60 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
61 where
62 E: serde::de::Error,
63 {
64 match value {
65 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
66 "data" => Ok(GeneratedField::Data),
67 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
68 }
69 }
70 }
71 deserializer.deserialize_identifier(GeneratedVisitor)
72 }
73 }
74 struct GeneratedVisitor;
75 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
76 type Value = ActorMapping;
77
78 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79 formatter.write_str("struct stream_plan.ActorMapping")
80 }
81
82 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
83 where
84 V: serde::de::MapAccess<'de>,
85 {
86 let mut original_indices__ = None;
87 let mut data__ = None;
88 while let Some(k) = map_.next_key()? {
89 match k {
90 GeneratedField::OriginalIndices => {
91 if original_indices__.is_some() {
92 return Err(serde::de::Error::duplicate_field("originalIndices"));
93 }
94 original_indices__ =
95 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
96 .into_iter().map(|x| x.0).collect())
97 ;
98 }
99 GeneratedField::Data => {
100 if data__.is_some() {
101 return Err(serde::de::Error::duplicate_field("data"));
102 }
103 data__ =
104 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
105 .into_iter().map(|x| x.0).collect())
106 ;
107 }
108 }
109 }
110 Ok(ActorMapping {
111 original_indices: original_indices__.unwrap_or_default(),
112 data: data__.unwrap_or_default(),
113 })
114 }
115 }
116 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
117 }
118}
119impl serde::Serialize for AddMutation {
120 #[allow(deprecated)]
121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
122 where
123 S: serde::Serializer,
124 {
125 use serde::ser::SerializeStruct;
126 let mut len = 0;
127 if !self.actor_dispatchers.is_empty() {
128 len += 1;
129 }
130 if !self.added_actors.is_empty() {
131 len += 1;
132 }
133 if !self.actor_splits.is_empty() {
134 len += 1;
135 }
136 if self.pause {
137 len += 1;
138 }
139 if !self.subscriptions_to_add.is_empty() {
140 len += 1;
141 }
142 if !self.backfill_nodes_to_pause.is_empty() {
143 len += 1;
144 }
145 if self.actor_cdc_table_snapshot_splits.is_some() {
146 len += 1;
147 }
148 if !self.new_upstream_sinks.is_empty() {
149 len += 1;
150 }
151 if !self.dropped_actors.is_empty() {
152 len += 1;
153 }
154 if !self.sink_log_store_flush.is_empty() {
155 len += 1;
156 }
157 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
158 if !self.actor_dispatchers.is_empty() {
159 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
160 }
161 if !self.added_actors.is_empty() {
162 struct_ser.serialize_field("addedActors", &self.added_actors)?;
163 }
164 if !self.actor_splits.is_empty() {
165 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
166 }
167 if self.pause {
168 struct_ser.serialize_field("pause", &self.pause)?;
169 }
170 if !self.subscriptions_to_add.is_empty() {
171 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
172 }
173 if !self.backfill_nodes_to_pause.is_empty() {
174 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
175 }
176 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
177 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
178 }
179 if !self.new_upstream_sinks.is_empty() {
180 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
181 }
182 if !self.dropped_actors.is_empty() {
183 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
184 }
185 if !self.sink_log_store_flush.is_empty() {
186 struct_ser.serialize_field("sinkLogStoreFlush", &self.sink_log_store_flush)?;
187 }
188 struct_ser.end()
189 }
190}
191impl<'de> serde::Deserialize<'de> for AddMutation {
192 #[allow(deprecated)]
193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
194 where
195 D: serde::Deserializer<'de>,
196 {
197 const FIELDS: &[&str] = &[
198 "actor_dispatchers",
199 "actorDispatchers",
200 "added_actors",
201 "addedActors",
202 "actor_splits",
203 "actorSplits",
204 "pause",
205 "subscriptions_to_add",
206 "subscriptionsToAdd",
207 "backfill_nodes_to_pause",
208 "backfillNodesToPause",
209 "actor_cdc_table_snapshot_splits",
210 "actorCdcTableSnapshotSplits",
211 "new_upstream_sinks",
212 "newUpstreamSinks",
213 "dropped_actors",
214 "droppedActors",
215 "sink_log_store_flush",
216 "sinkLogStoreFlush",
217 ];
218
219 #[allow(clippy::enum_variant_names)]
220 enum GeneratedField {
221 ActorDispatchers,
222 AddedActors,
223 ActorSplits,
224 Pause,
225 SubscriptionsToAdd,
226 BackfillNodesToPause,
227 ActorCdcTableSnapshotSplits,
228 NewUpstreamSinks,
229 DroppedActors,
230 SinkLogStoreFlush,
231 }
232 impl<'de> serde::Deserialize<'de> for GeneratedField {
233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
234 where
235 D: serde::Deserializer<'de>,
236 {
237 struct GeneratedVisitor;
238
239 impl serde::de::Visitor<'_> for GeneratedVisitor {
240 type Value = GeneratedField;
241
242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
243 write!(formatter, "expected one of: {:?}", &FIELDS)
244 }
245
246 #[allow(unused_variables)]
247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
248 where
249 E: serde::de::Error,
250 {
251 match value {
252 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
253 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
254 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
255 "pause" => Ok(GeneratedField::Pause),
256 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
257 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
258 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
259 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
260 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
261 "sinkLogStoreFlush" | "sink_log_store_flush" => Ok(GeneratedField::SinkLogStoreFlush),
262 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
263 }
264 }
265 }
266 deserializer.deserialize_identifier(GeneratedVisitor)
267 }
268 }
269 struct GeneratedVisitor;
270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
271 type Value = AddMutation;
272
273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
274 formatter.write_str("struct stream_plan.AddMutation")
275 }
276
277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
278 where
279 V: serde::de::MapAccess<'de>,
280 {
281 let mut actor_dispatchers__ = None;
282 let mut added_actors__ = None;
283 let mut actor_splits__ = None;
284 let mut pause__ = None;
285 let mut subscriptions_to_add__ = None;
286 let mut backfill_nodes_to_pause__ = None;
287 let mut actor_cdc_table_snapshot_splits__ = None;
288 let mut new_upstream_sinks__ = None;
289 let mut dropped_actors__ = None;
290 let mut sink_log_store_flush__ = None;
291 while let Some(k) = map_.next_key()? {
292 match k {
293 GeneratedField::ActorDispatchers => {
294 if actor_dispatchers__.is_some() {
295 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
296 }
297 actor_dispatchers__ = Some(
298 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
299 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
300 );
301 }
302 GeneratedField::AddedActors => {
303 if added_actors__.is_some() {
304 return Err(serde::de::Error::duplicate_field("addedActors"));
305 }
306 added_actors__ =
307 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
308 .into_iter().map(|x| x.0).collect())
309 ;
310 }
311 GeneratedField::ActorSplits => {
312 if actor_splits__.is_some() {
313 return Err(serde::de::Error::duplicate_field("actorSplits"));
314 }
315 actor_splits__ = Some(
316 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
317 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
318 );
319 }
320 GeneratedField::Pause => {
321 if pause__.is_some() {
322 return Err(serde::de::Error::duplicate_field("pause"));
323 }
324 pause__ = Some(map_.next_value()?);
325 }
326 GeneratedField::SubscriptionsToAdd => {
327 if subscriptions_to_add__.is_some() {
328 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
329 }
330 subscriptions_to_add__ = Some(map_.next_value()?);
331 }
332 GeneratedField::BackfillNodesToPause => {
333 if backfill_nodes_to_pause__.is_some() {
334 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
335 }
336 backfill_nodes_to_pause__ =
337 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
338 .into_iter().map(|x| x.0).collect())
339 ;
340 }
341 GeneratedField::ActorCdcTableSnapshotSplits => {
342 if actor_cdc_table_snapshot_splits__.is_some() {
343 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
344 }
345 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
346 }
347 GeneratedField::NewUpstreamSinks => {
348 if new_upstream_sinks__.is_some() {
349 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
350 }
351 new_upstream_sinks__ = Some(
352 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
353 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
354 );
355 }
356 GeneratedField::DroppedActors => {
357 if dropped_actors__.is_some() {
358 return Err(serde::de::Error::duplicate_field("droppedActors"));
359 }
360 dropped_actors__ =
361 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
362 .into_iter().map(|x| x.0).collect())
363 ;
364 }
365 GeneratedField::SinkLogStoreFlush => {
366 if sink_log_store_flush__.is_some() {
367 return Err(serde::de::Error::duplicate_field("sinkLogStoreFlush"));
368 }
369 sink_log_store_flush__ =
370 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
371 .into_iter().map(|x| x.0).collect())
372 ;
373 }
374 }
375 }
376 Ok(AddMutation {
377 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
378 added_actors: added_actors__.unwrap_or_default(),
379 actor_splits: actor_splits__.unwrap_or_default(),
380 pause: pause__.unwrap_or_default(),
381 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
382 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
383 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
384 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
385 dropped_actors: dropped_actors__.unwrap_or_default(),
386 sink_log_store_flush: sink_log_store_flush__.unwrap_or_default(),
387 })
388 }
389 }
390 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
391 }
392}
393impl serde::Serialize for add_mutation::NewUpstreamSink {
394 #[allow(deprecated)]
395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
396 where
397 S: serde::Serializer,
398 {
399 use serde::ser::SerializeStruct;
400 let mut len = 0;
401 if self.info.is_some() {
402 len += 1;
403 }
404 if !self.upstream_actors.is_empty() {
405 len += 1;
406 }
407 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
408 if let Some(v) = self.info.as_ref() {
409 struct_ser.serialize_field("info", v)?;
410 }
411 if !self.upstream_actors.is_empty() {
412 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
413 }
414 struct_ser.end()
415 }
416}
417impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
418 #[allow(deprecated)]
419 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
420 where
421 D: serde::Deserializer<'de>,
422 {
423 const FIELDS: &[&str] = &[
424 "info",
425 "upstream_actors",
426 "upstreamActors",
427 ];
428
429 #[allow(clippy::enum_variant_names)]
430 enum GeneratedField {
431 Info,
432 UpstreamActors,
433 }
434 impl<'de> serde::Deserialize<'de> for GeneratedField {
435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
436 where
437 D: serde::Deserializer<'de>,
438 {
439 struct GeneratedVisitor;
440
441 impl serde::de::Visitor<'_> for GeneratedVisitor {
442 type Value = GeneratedField;
443
444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
445 write!(formatter, "expected one of: {:?}", &FIELDS)
446 }
447
448 #[allow(unused_variables)]
449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
450 where
451 E: serde::de::Error,
452 {
453 match value {
454 "info" => Ok(GeneratedField::Info),
455 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
457 }
458 }
459 }
460 deserializer.deserialize_identifier(GeneratedVisitor)
461 }
462 }
463 struct GeneratedVisitor;
464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
465 type Value = add_mutation::NewUpstreamSink;
466
467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
468 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
469 }
470
471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
472 where
473 V: serde::de::MapAccess<'de>,
474 {
475 let mut info__ = None;
476 let mut upstream_actors__ = None;
477 while let Some(k) = map_.next_key()? {
478 match k {
479 GeneratedField::Info => {
480 if info__.is_some() {
481 return Err(serde::de::Error::duplicate_field("info"));
482 }
483 info__ = map_.next_value()?;
484 }
485 GeneratedField::UpstreamActors => {
486 if upstream_actors__.is_some() {
487 return Err(serde::de::Error::duplicate_field("upstreamActors"));
488 }
489 upstream_actors__ = Some(map_.next_value()?);
490 }
491 }
492 }
493 Ok(add_mutation::NewUpstreamSink {
494 info: info__,
495 upstream_actors: upstream_actors__.unwrap_or_default(),
496 })
497 }
498 }
499 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
500 }
501}
502impl serde::Serialize for AggCallState {
503 #[allow(deprecated)]
504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
505 where
506 S: serde::Serializer,
507 {
508 use serde::ser::SerializeStruct;
509 let mut len = 0;
510 if self.inner.is_some() {
511 len += 1;
512 }
513 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
514 if let Some(v) = self.inner.as_ref() {
515 match v {
516 agg_call_state::Inner::ValueState(v) => {
517 struct_ser.serialize_field("valueState", v)?;
518 }
519 agg_call_state::Inner::MaterializedInputState(v) => {
520 struct_ser.serialize_field("materializedInputState", v)?;
521 }
522 }
523 }
524 struct_ser.end()
525 }
526}
527impl<'de> serde::Deserialize<'de> for AggCallState {
528 #[allow(deprecated)]
529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
530 where
531 D: serde::Deserializer<'de>,
532 {
533 const FIELDS: &[&str] = &[
534 "value_state",
535 "valueState",
536 "materialized_input_state",
537 "materializedInputState",
538 ];
539
540 #[allow(clippy::enum_variant_names)]
541 enum GeneratedField {
542 ValueState,
543 MaterializedInputState,
544 }
545 impl<'de> serde::Deserialize<'de> for GeneratedField {
546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
547 where
548 D: serde::Deserializer<'de>,
549 {
550 struct GeneratedVisitor;
551
552 impl serde::de::Visitor<'_> for GeneratedVisitor {
553 type Value = GeneratedField;
554
555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
556 write!(formatter, "expected one of: {:?}", &FIELDS)
557 }
558
559 #[allow(unused_variables)]
560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
561 where
562 E: serde::de::Error,
563 {
564 match value {
565 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
566 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
567 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
568 }
569 }
570 }
571 deserializer.deserialize_identifier(GeneratedVisitor)
572 }
573 }
574 struct GeneratedVisitor;
575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
576 type Value = AggCallState;
577
578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
579 formatter.write_str("struct stream_plan.AggCallState")
580 }
581
582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
583 where
584 V: serde::de::MapAccess<'de>,
585 {
586 let mut inner__ = None;
587 while let Some(k) = map_.next_key()? {
588 match k {
589 GeneratedField::ValueState => {
590 if inner__.is_some() {
591 return Err(serde::de::Error::duplicate_field("valueState"));
592 }
593 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
594;
595 }
596 GeneratedField::MaterializedInputState => {
597 if inner__.is_some() {
598 return Err(serde::de::Error::duplicate_field("materializedInputState"));
599 }
600 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
601;
602 }
603 }
604 }
605 Ok(AggCallState {
606 inner: inner__,
607 })
608 }
609 }
610 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
611 }
612}
613impl serde::Serialize for agg_call_state::MaterializedInputState {
614 #[allow(deprecated)]
615 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
616 where
617 S: serde::Serializer,
618 {
619 use serde::ser::SerializeStruct;
620 let mut len = 0;
621 if self.table.is_some() {
622 len += 1;
623 }
624 if !self.included_upstream_indices.is_empty() {
625 len += 1;
626 }
627 if !self.table_value_indices.is_empty() {
628 len += 1;
629 }
630 if !self.order_columns.is_empty() {
631 len += 1;
632 }
633 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
634 if let Some(v) = self.table.as_ref() {
635 struct_ser.serialize_field("table", v)?;
636 }
637 if !self.included_upstream_indices.is_empty() {
638 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
639 }
640 if !self.table_value_indices.is_empty() {
641 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
642 }
643 if !self.order_columns.is_empty() {
644 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
645 }
646 struct_ser.end()
647 }
648}
649impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
650 #[allow(deprecated)]
651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
652 where
653 D: serde::Deserializer<'de>,
654 {
655 const FIELDS: &[&str] = &[
656 "table",
657 "included_upstream_indices",
658 "includedUpstreamIndices",
659 "table_value_indices",
660 "tableValueIndices",
661 "order_columns",
662 "orderColumns",
663 ];
664
665 #[allow(clippy::enum_variant_names)]
666 enum GeneratedField {
667 Table,
668 IncludedUpstreamIndices,
669 TableValueIndices,
670 OrderColumns,
671 }
672 impl<'de> serde::Deserialize<'de> for GeneratedField {
673 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
674 where
675 D: serde::Deserializer<'de>,
676 {
677 struct GeneratedVisitor;
678
679 impl serde::de::Visitor<'_> for GeneratedVisitor {
680 type Value = GeneratedField;
681
682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
683 write!(formatter, "expected one of: {:?}", &FIELDS)
684 }
685
686 #[allow(unused_variables)]
687 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
688 where
689 E: serde::de::Error,
690 {
691 match value {
692 "table" => Ok(GeneratedField::Table),
693 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
694 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
695 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
696 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
697 }
698 }
699 }
700 deserializer.deserialize_identifier(GeneratedVisitor)
701 }
702 }
703 struct GeneratedVisitor;
704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
705 type Value = agg_call_state::MaterializedInputState;
706
707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
708 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
709 }
710
711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
712 where
713 V: serde::de::MapAccess<'de>,
714 {
715 let mut table__ = None;
716 let mut included_upstream_indices__ = None;
717 let mut table_value_indices__ = None;
718 let mut order_columns__ = None;
719 while let Some(k) = map_.next_key()? {
720 match k {
721 GeneratedField::Table => {
722 if table__.is_some() {
723 return Err(serde::de::Error::duplicate_field("table"));
724 }
725 table__ = map_.next_value()?;
726 }
727 GeneratedField::IncludedUpstreamIndices => {
728 if included_upstream_indices__.is_some() {
729 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
730 }
731 included_upstream_indices__ =
732 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
733 .into_iter().map(|x| x.0).collect())
734 ;
735 }
736 GeneratedField::TableValueIndices => {
737 if table_value_indices__.is_some() {
738 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
739 }
740 table_value_indices__ =
741 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
742 .into_iter().map(|x| x.0).collect())
743 ;
744 }
745 GeneratedField::OrderColumns => {
746 if order_columns__.is_some() {
747 return Err(serde::de::Error::duplicate_field("orderColumns"));
748 }
749 order_columns__ = Some(map_.next_value()?);
750 }
751 }
752 }
753 Ok(agg_call_state::MaterializedInputState {
754 table: table__,
755 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
756 table_value_indices: table_value_indices__.unwrap_or_default(),
757 order_columns: order_columns__.unwrap_or_default(),
758 })
759 }
760 }
761 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
762 }
763}
764impl serde::Serialize for agg_call_state::ValueState {
765 #[allow(deprecated)]
766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
767 where
768 S: serde::Serializer,
769 {
770 use serde::ser::SerializeStruct;
771 let len = 0;
772 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
773 struct_ser.end()
774 }
775}
776impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
777 #[allow(deprecated)]
778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
779 where
780 D: serde::Deserializer<'de>,
781 {
782 const FIELDS: &[&str] = &[
783 ];
784
785 #[allow(clippy::enum_variant_names)]
786 enum GeneratedField {
787 }
788 impl<'de> serde::Deserialize<'de> for GeneratedField {
789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
790 where
791 D: serde::Deserializer<'de>,
792 {
793 struct GeneratedVisitor;
794
795 impl serde::de::Visitor<'_> for GeneratedVisitor {
796 type Value = GeneratedField;
797
798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
799 write!(formatter, "expected one of: {:?}", &FIELDS)
800 }
801
802 #[allow(unused_variables)]
803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
804 where
805 E: serde::de::Error,
806 {
807 Err(serde::de::Error::unknown_field(value, FIELDS))
808 }
809 }
810 deserializer.deserialize_identifier(GeneratedVisitor)
811 }
812 }
813 struct GeneratedVisitor;
814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
815 type Value = agg_call_state::ValueState;
816
817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
818 formatter.write_str("struct stream_plan.AggCallState.ValueState")
819 }
820
821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
822 where
823 V: serde::de::MapAccess<'de>,
824 {
825 while map_.next_key::<GeneratedField>()?.is_some() {
826 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
827 }
828 Ok(agg_call_state::ValueState {
829 })
830 }
831 }
832 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
833 }
834}
835impl serde::Serialize for AggNodeVersion {
836 #[allow(deprecated)]
837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
838 where
839 S: serde::Serializer,
840 {
841 let variant = match self {
842 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
843 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
844 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
845 };
846 serializer.serialize_str(variant)
847 }
848}
849impl<'de> serde::Deserialize<'de> for AggNodeVersion {
850 #[allow(deprecated)]
851 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
852 where
853 D: serde::Deserializer<'de>,
854 {
855 const FIELDS: &[&str] = &[
856 "AGG_NODE_VERSION_UNSPECIFIED",
857 "AGG_NODE_VERSION_ISSUE_12140",
858 "AGG_NODE_VERSION_ISSUE_13465",
859 ];
860
861 struct GeneratedVisitor;
862
863 impl serde::de::Visitor<'_> for GeneratedVisitor {
864 type Value = AggNodeVersion;
865
866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
867 write!(formatter, "expected one of: {:?}", &FIELDS)
868 }
869
870 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
871 where
872 E: serde::de::Error,
873 {
874 i32::try_from(v)
875 .ok()
876 .and_then(|x| x.try_into().ok())
877 .ok_or_else(|| {
878 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
879 })
880 }
881
882 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
883 where
884 E: serde::de::Error,
885 {
886 i32::try_from(v)
887 .ok()
888 .and_then(|x| x.try_into().ok())
889 .ok_or_else(|| {
890 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
891 })
892 }
893
894 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
895 where
896 E: serde::de::Error,
897 {
898 match value {
899 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
900 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
901 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
902 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
903 }
904 }
905 }
906 deserializer.deserialize_any(GeneratedVisitor)
907 }
908}
909impl serde::Serialize for ArrangeNode {
910 #[allow(deprecated)]
911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
912 where
913 S: serde::Serializer,
914 {
915 use serde::ser::SerializeStruct;
916 let mut len = 0;
917 if self.table_info.is_some() {
918 len += 1;
919 }
920 if !self.distribution_key.is_empty() {
921 len += 1;
922 }
923 if self.table.is_some() {
924 len += 1;
925 }
926 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
927 if let Some(v) = self.table_info.as_ref() {
928 struct_ser.serialize_field("tableInfo", v)?;
929 }
930 if !self.distribution_key.is_empty() {
931 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
932 }
933 if let Some(v) = self.table.as_ref() {
934 struct_ser.serialize_field("table", v)?;
935 }
936 struct_ser.end()
937 }
938}
939impl<'de> serde::Deserialize<'de> for ArrangeNode {
940 #[allow(deprecated)]
941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
942 where
943 D: serde::Deserializer<'de>,
944 {
945 const FIELDS: &[&str] = &[
946 "table_info",
947 "tableInfo",
948 "distribution_key",
949 "distributionKey",
950 "table",
951 ];
952
953 #[allow(clippy::enum_variant_names)]
954 enum GeneratedField {
955 TableInfo,
956 DistributionKey,
957 Table,
958 }
959 impl<'de> serde::Deserialize<'de> for GeneratedField {
960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
961 where
962 D: serde::Deserializer<'de>,
963 {
964 struct GeneratedVisitor;
965
966 impl serde::de::Visitor<'_> for GeneratedVisitor {
967 type Value = GeneratedField;
968
969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
970 write!(formatter, "expected one of: {:?}", &FIELDS)
971 }
972
973 #[allow(unused_variables)]
974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
975 where
976 E: serde::de::Error,
977 {
978 match value {
979 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
980 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
981 "table" => Ok(GeneratedField::Table),
982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
983 }
984 }
985 }
986 deserializer.deserialize_identifier(GeneratedVisitor)
987 }
988 }
989 struct GeneratedVisitor;
990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
991 type Value = ArrangeNode;
992
993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
994 formatter.write_str("struct stream_plan.ArrangeNode")
995 }
996
997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
998 where
999 V: serde::de::MapAccess<'de>,
1000 {
1001 let mut table_info__ = None;
1002 let mut distribution_key__ = None;
1003 let mut table__ = None;
1004 while let Some(k) = map_.next_key()? {
1005 match k {
1006 GeneratedField::TableInfo => {
1007 if table_info__.is_some() {
1008 return Err(serde::de::Error::duplicate_field("tableInfo"));
1009 }
1010 table_info__ = map_.next_value()?;
1011 }
1012 GeneratedField::DistributionKey => {
1013 if distribution_key__.is_some() {
1014 return Err(serde::de::Error::duplicate_field("distributionKey"));
1015 }
1016 distribution_key__ =
1017 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1018 .into_iter().map(|x| x.0).collect())
1019 ;
1020 }
1021 GeneratedField::Table => {
1022 if table__.is_some() {
1023 return Err(serde::de::Error::duplicate_field("table"));
1024 }
1025 table__ = map_.next_value()?;
1026 }
1027 }
1028 }
1029 Ok(ArrangeNode {
1030 table_info: table_info__,
1031 distribution_key: distribution_key__.unwrap_or_default(),
1032 table: table__,
1033 })
1034 }
1035 }
1036 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
1037 }
1038}
1039impl serde::Serialize for ArrangementInfo {
1040 #[allow(deprecated)]
1041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1042 where
1043 S: serde::Serializer,
1044 {
1045 use serde::ser::SerializeStruct;
1046 let mut len = 0;
1047 if !self.arrange_key_orders.is_empty() {
1048 len += 1;
1049 }
1050 if !self.column_descs.is_empty() {
1051 len += 1;
1052 }
1053 if self.table_desc.is_some() {
1054 len += 1;
1055 }
1056 if !self.output_col_idx.is_empty() {
1057 len += 1;
1058 }
1059 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1060 if !self.arrange_key_orders.is_empty() {
1061 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1062 }
1063 if !self.column_descs.is_empty() {
1064 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1065 }
1066 if let Some(v) = self.table_desc.as_ref() {
1067 struct_ser.serialize_field("tableDesc", v)?;
1068 }
1069 if !self.output_col_idx.is_empty() {
1070 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1071 }
1072 struct_ser.end()
1073 }
1074}
1075impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1076 #[allow(deprecated)]
1077 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1078 where
1079 D: serde::Deserializer<'de>,
1080 {
1081 const FIELDS: &[&str] = &[
1082 "arrange_key_orders",
1083 "arrangeKeyOrders",
1084 "column_descs",
1085 "columnDescs",
1086 "table_desc",
1087 "tableDesc",
1088 "output_col_idx",
1089 "outputColIdx",
1090 ];
1091
1092 #[allow(clippy::enum_variant_names)]
1093 enum GeneratedField {
1094 ArrangeKeyOrders,
1095 ColumnDescs,
1096 TableDesc,
1097 OutputColIdx,
1098 }
1099 impl<'de> serde::Deserialize<'de> for GeneratedField {
1100 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1101 where
1102 D: serde::Deserializer<'de>,
1103 {
1104 struct GeneratedVisitor;
1105
1106 impl serde::de::Visitor<'_> for GeneratedVisitor {
1107 type Value = GeneratedField;
1108
1109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1110 write!(formatter, "expected one of: {:?}", &FIELDS)
1111 }
1112
1113 #[allow(unused_variables)]
1114 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1115 where
1116 E: serde::de::Error,
1117 {
1118 match value {
1119 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1120 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1121 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1122 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1124 }
1125 }
1126 }
1127 deserializer.deserialize_identifier(GeneratedVisitor)
1128 }
1129 }
1130 struct GeneratedVisitor;
1131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1132 type Value = ArrangementInfo;
1133
1134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1135 formatter.write_str("struct stream_plan.ArrangementInfo")
1136 }
1137
1138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1139 where
1140 V: serde::de::MapAccess<'de>,
1141 {
1142 let mut arrange_key_orders__ = None;
1143 let mut column_descs__ = None;
1144 let mut table_desc__ = None;
1145 let mut output_col_idx__ = None;
1146 while let Some(k) = map_.next_key()? {
1147 match k {
1148 GeneratedField::ArrangeKeyOrders => {
1149 if arrange_key_orders__.is_some() {
1150 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1151 }
1152 arrange_key_orders__ = Some(map_.next_value()?);
1153 }
1154 GeneratedField::ColumnDescs => {
1155 if column_descs__.is_some() {
1156 return Err(serde::de::Error::duplicate_field("columnDescs"));
1157 }
1158 column_descs__ = Some(map_.next_value()?);
1159 }
1160 GeneratedField::TableDesc => {
1161 if table_desc__.is_some() {
1162 return Err(serde::de::Error::duplicate_field("tableDesc"));
1163 }
1164 table_desc__ = map_.next_value()?;
1165 }
1166 GeneratedField::OutputColIdx => {
1167 if output_col_idx__.is_some() {
1168 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1169 }
1170 output_col_idx__ =
1171 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1172 .into_iter().map(|x| x.0).collect())
1173 ;
1174 }
1175 }
1176 }
1177 Ok(ArrangementInfo {
1178 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1179 column_descs: column_descs__.unwrap_or_default(),
1180 table_desc: table_desc__,
1181 output_col_idx: output_col_idx__.unwrap_or_default(),
1182 })
1183 }
1184 }
1185 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1186 }
1187}
1188impl serde::Serialize for AsOfJoinNode {
1189 #[allow(deprecated)]
1190 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1191 where
1192 S: serde::Serializer,
1193 {
1194 use serde::ser::SerializeStruct;
1195 let mut len = 0;
1196 if self.join_type != 0 {
1197 len += 1;
1198 }
1199 if !self.left_key.is_empty() {
1200 len += 1;
1201 }
1202 if !self.right_key.is_empty() {
1203 len += 1;
1204 }
1205 if self.left_table.is_some() {
1206 len += 1;
1207 }
1208 if self.right_table.is_some() {
1209 len += 1;
1210 }
1211 if !self.output_indices.is_empty() {
1212 len += 1;
1213 }
1214 if !self.left_deduped_input_pk_indices.is_empty() {
1215 len += 1;
1216 }
1217 if !self.right_deduped_input_pk_indices.is_empty() {
1218 len += 1;
1219 }
1220 if !self.null_safe.is_empty() {
1221 len += 1;
1222 }
1223 if self.asof_desc.is_some() {
1224 len += 1;
1225 }
1226 if self.join_encoding_type != 0 {
1227 len += 1;
1228 }
1229 if self.use_cache.is_some() {
1230 len += 1;
1231 }
1232 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1233 if self.join_type != 0 {
1234 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1235 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1236 struct_ser.serialize_field("joinType", &v)?;
1237 }
1238 if !self.left_key.is_empty() {
1239 struct_ser.serialize_field("leftKey", &self.left_key)?;
1240 }
1241 if !self.right_key.is_empty() {
1242 struct_ser.serialize_field("rightKey", &self.right_key)?;
1243 }
1244 if let Some(v) = self.left_table.as_ref() {
1245 struct_ser.serialize_field("leftTable", v)?;
1246 }
1247 if let Some(v) = self.right_table.as_ref() {
1248 struct_ser.serialize_field("rightTable", v)?;
1249 }
1250 if !self.output_indices.is_empty() {
1251 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1252 }
1253 if !self.left_deduped_input_pk_indices.is_empty() {
1254 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1255 }
1256 if !self.right_deduped_input_pk_indices.is_empty() {
1257 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1258 }
1259 if !self.null_safe.is_empty() {
1260 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1261 }
1262 if let Some(v) = self.asof_desc.as_ref() {
1263 struct_ser.serialize_field("asofDesc", v)?;
1264 }
1265 if self.join_encoding_type != 0 {
1266 let v = JoinEncodingType::try_from(self.join_encoding_type)
1267 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1268 struct_ser.serialize_field("joinEncodingType", &v)?;
1269 }
1270 if let Some(v) = self.use_cache.as_ref() {
1271 struct_ser.serialize_field("useCache", v)?;
1272 }
1273 struct_ser.end()
1274 }
1275}
1276impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1277 #[allow(deprecated)]
1278 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1279 where
1280 D: serde::Deserializer<'de>,
1281 {
1282 const FIELDS: &[&str] = &[
1283 "join_type",
1284 "joinType",
1285 "left_key",
1286 "leftKey",
1287 "right_key",
1288 "rightKey",
1289 "left_table",
1290 "leftTable",
1291 "right_table",
1292 "rightTable",
1293 "output_indices",
1294 "outputIndices",
1295 "left_deduped_input_pk_indices",
1296 "leftDedupedInputPkIndices",
1297 "right_deduped_input_pk_indices",
1298 "rightDedupedInputPkIndices",
1299 "null_safe",
1300 "nullSafe",
1301 "asof_desc",
1302 "asofDesc",
1303 "join_encoding_type",
1304 "joinEncodingType",
1305 "use_cache",
1306 "useCache",
1307 ];
1308
1309 #[allow(clippy::enum_variant_names)]
1310 enum GeneratedField {
1311 JoinType,
1312 LeftKey,
1313 RightKey,
1314 LeftTable,
1315 RightTable,
1316 OutputIndices,
1317 LeftDedupedInputPkIndices,
1318 RightDedupedInputPkIndices,
1319 NullSafe,
1320 AsofDesc,
1321 JoinEncodingType,
1322 UseCache,
1323 }
1324 impl<'de> serde::Deserialize<'de> for GeneratedField {
1325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1326 where
1327 D: serde::Deserializer<'de>,
1328 {
1329 struct GeneratedVisitor;
1330
1331 impl serde::de::Visitor<'_> for GeneratedVisitor {
1332 type Value = GeneratedField;
1333
1334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1335 write!(formatter, "expected one of: {:?}", &FIELDS)
1336 }
1337
1338 #[allow(unused_variables)]
1339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1340 where
1341 E: serde::de::Error,
1342 {
1343 match value {
1344 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1345 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1346 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1347 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1348 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1349 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1350 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1351 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1352 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1353 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1354 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1355 "useCache" | "use_cache" => Ok(GeneratedField::UseCache),
1356 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1357 }
1358 }
1359 }
1360 deserializer.deserialize_identifier(GeneratedVisitor)
1361 }
1362 }
1363 struct GeneratedVisitor;
1364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1365 type Value = AsOfJoinNode;
1366
1367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1368 formatter.write_str("struct stream_plan.AsOfJoinNode")
1369 }
1370
1371 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1372 where
1373 V: serde::de::MapAccess<'de>,
1374 {
1375 let mut join_type__ = None;
1376 let mut left_key__ = None;
1377 let mut right_key__ = None;
1378 let mut left_table__ = None;
1379 let mut right_table__ = None;
1380 let mut output_indices__ = None;
1381 let mut left_deduped_input_pk_indices__ = None;
1382 let mut right_deduped_input_pk_indices__ = None;
1383 let mut null_safe__ = None;
1384 let mut asof_desc__ = None;
1385 let mut join_encoding_type__ = None;
1386 let mut use_cache__ = None;
1387 while let Some(k) = map_.next_key()? {
1388 match k {
1389 GeneratedField::JoinType => {
1390 if join_type__.is_some() {
1391 return Err(serde::de::Error::duplicate_field("joinType"));
1392 }
1393 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1394 }
1395 GeneratedField::LeftKey => {
1396 if left_key__.is_some() {
1397 return Err(serde::de::Error::duplicate_field("leftKey"));
1398 }
1399 left_key__ =
1400 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1401 .into_iter().map(|x| x.0).collect())
1402 ;
1403 }
1404 GeneratedField::RightKey => {
1405 if right_key__.is_some() {
1406 return Err(serde::de::Error::duplicate_field("rightKey"));
1407 }
1408 right_key__ =
1409 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1410 .into_iter().map(|x| x.0).collect())
1411 ;
1412 }
1413 GeneratedField::LeftTable => {
1414 if left_table__.is_some() {
1415 return Err(serde::de::Error::duplicate_field("leftTable"));
1416 }
1417 left_table__ = map_.next_value()?;
1418 }
1419 GeneratedField::RightTable => {
1420 if right_table__.is_some() {
1421 return Err(serde::de::Error::duplicate_field("rightTable"));
1422 }
1423 right_table__ = map_.next_value()?;
1424 }
1425 GeneratedField::OutputIndices => {
1426 if output_indices__.is_some() {
1427 return Err(serde::de::Error::duplicate_field("outputIndices"));
1428 }
1429 output_indices__ =
1430 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1431 .into_iter().map(|x| x.0).collect())
1432 ;
1433 }
1434 GeneratedField::LeftDedupedInputPkIndices => {
1435 if left_deduped_input_pk_indices__.is_some() {
1436 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1437 }
1438 left_deduped_input_pk_indices__ =
1439 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1440 .into_iter().map(|x| x.0).collect())
1441 ;
1442 }
1443 GeneratedField::RightDedupedInputPkIndices => {
1444 if right_deduped_input_pk_indices__.is_some() {
1445 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1446 }
1447 right_deduped_input_pk_indices__ =
1448 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1449 .into_iter().map(|x| x.0).collect())
1450 ;
1451 }
1452 GeneratedField::NullSafe => {
1453 if null_safe__.is_some() {
1454 return Err(serde::de::Error::duplicate_field("nullSafe"));
1455 }
1456 null_safe__ = Some(map_.next_value()?);
1457 }
1458 GeneratedField::AsofDesc => {
1459 if asof_desc__.is_some() {
1460 return Err(serde::de::Error::duplicate_field("asofDesc"));
1461 }
1462 asof_desc__ = map_.next_value()?;
1463 }
1464 GeneratedField::JoinEncodingType => {
1465 if join_encoding_type__.is_some() {
1466 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1467 }
1468 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1469 }
1470 GeneratedField::UseCache => {
1471 if use_cache__.is_some() {
1472 return Err(serde::de::Error::duplicate_field("useCache"));
1473 }
1474 use_cache__ = map_.next_value()?;
1475 }
1476 }
1477 }
1478 Ok(AsOfJoinNode {
1479 join_type: join_type__.unwrap_or_default(),
1480 left_key: left_key__.unwrap_or_default(),
1481 right_key: right_key__.unwrap_or_default(),
1482 left_table: left_table__,
1483 right_table: right_table__,
1484 output_indices: output_indices__.unwrap_or_default(),
1485 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1486 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1487 null_safe: null_safe__.unwrap_or_default(),
1488 asof_desc: asof_desc__,
1489 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1490 use_cache: use_cache__,
1491 })
1492 }
1493 }
1494 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1495 }
1496}
1497impl serde::Serialize for BackfillOrder {
1498 #[allow(deprecated)]
1499 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1500 where
1501 S: serde::Serializer,
1502 {
1503 use serde::ser::SerializeStruct;
1504 let mut len = 0;
1505 if !self.order.is_empty() {
1506 len += 1;
1507 }
1508 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1509 if !self.order.is_empty() {
1510 struct_ser.serialize_field("order", &self.order)?;
1511 }
1512 struct_ser.end()
1513 }
1514}
1515impl<'de> serde::Deserialize<'de> for BackfillOrder {
1516 #[allow(deprecated)]
1517 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1518 where
1519 D: serde::Deserializer<'de>,
1520 {
1521 const FIELDS: &[&str] = &[
1522 "order",
1523 ];
1524
1525 #[allow(clippy::enum_variant_names)]
1526 enum GeneratedField {
1527 Order,
1528 }
1529 impl<'de> serde::Deserialize<'de> for GeneratedField {
1530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1531 where
1532 D: serde::Deserializer<'de>,
1533 {
1534 struct GeneratedVisitor;
1535
1536 impl serde::de::Visitor<'_> for GeneratedVisitor {
1537 type Value = GeneratedField;
1538
1539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1540 write!(formatter, "expected one of: {:?}", &FIELDS)
1541 }
1542
1543 #[allow(unused_variables)]
1544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1545 where
1546 E: serde::de::Error,
1547 {
1548 match value {
1549 "order" => Ok(GeneratedField::Order),
1550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1551 }
1552 }
1553 }
1554 deserializer.deserialize_identifier(GeneratedVisitor)
1555 }
1556 }
1557 struct GeneratedVisitor;
1558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1559 type Value = BackfillOrder;
1560
1561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1562 formatter.write_str("struct stream_plan.BackfillOrder")
1563 }
1564
1565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1566 where
1567 V: serde::de::MapAccess<'de>,
1568 {
1569 let mut order__ = None;
1570 while let Some(k) = map_.next_key()? {
1571 match k {
1572 GeneratedField::Order => {
1573 if order__.is_some() {
1574 return Err(serde::de::Error::duplicate_field("order"));
1575 }
1576 order__ = Some(
1577 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1578 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1579 );
1580 }
1581 }
1582 }
1583 Ok(BackfillOrder {
1584 order: order__.unwrap_or_default(),
1585 })
1586 }
1587 }
1588 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1589 }
1590}
1591impl serde::Serialize for Barrier {
1592 #[allow(deprecated)]
1593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1594 where
1595 S: serde::Serializer,
1596 {
1597 use serde::ser::SerializeStruct;
1598 let mut len = 0;
1599 if self.epoch.is_some() {
1600 len += 1;
1601 }
1602 if self.mutation.is_some() {
1603 len += 1;
1604 }
1605 if !self.tracing_context.is_empty() {
1606 len += 1;
1607 }
1608 if self.kind != 0 {
1609 len += 1;
1610 }
1611 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1612 if let Some(v) = self.epoch.as_ref() {
1613 struct_ser.serialize_field("epoch", v)?;
1614 }
1615 if let Some(v) = self.mutation.as_ref() {
1616 struct_ser.serialize_field("mutation", v)?;
1617 }
1618 if !self.tracing_context.is_empty() {
1619 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1620 }
1621 if self.kind != 0 {
1622 let v = barrier::BarrierKind::try_from(self.kind)
1623 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1624 struct_ser.serialize_field("kind", &v)?;
1625 }
1626 struct_ser.end()
1627 }
1628}
1629impl<'de> serde::Deserialize<'de> for Barrier {
1630 #[allow(deprecated)]
1631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1632 where
1633 D: serde::Deserializer<'de>,
1634 {
1635 const FIELDS: &[&str] = &[
1636 "epoch",
1637 "mutation",
1638 "tracing_context",
1639 "tracingContext",
1640 "kind",
1641 ];
1642
1643 #[allow(clippy::enum_variant_names)]
1644 enum GeneratedField {
1645 Epoch,
1646 Mutation,
1647 TracingContext,
1648 Kind,
1649 }
1650 impl<'de> serde::Deserialize<'de> for GeneratedField {
1651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1652 where
1653 D: serde::Deserializer<'de>,
1654 {
1655 struct GeneratedVisitor;
1656
1657 impl serde::de::Visitor<'_> for GeneratedVisitor {
1658 type Value = GeneratedField;
1659
1660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1661 write!(formatter, "expected one of: {:?}", &FIELDS)
1662 }
1663
1664 #[allow(unused_variables)]
1665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1666 where
1667 E: serde::de::Error,
1668 {
1669 match value {
1670 "epoch" => Ok(GeneratedField::Epoch),
1671 "mutation" => Ok(GeneratedField::Mutation),
1672 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1673 "kind" => Ok(GeneratedField::Kind),
1674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1675 }
1676 }
1677 }
1678 deserializer.deserialize_identifier(GeneratedVisitor)
1679 }
1680 }
1681 struct GeneratedVisitor;
1682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1683 type Value = Barrier;
1684
1685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1686 formatter.write_str("struct stream_plan.Barrier")
1687 }
1688
1689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1690 where
1691 V: serde::de::MapAccess<'de>,
1692 {
1693 let mut epoch__ = None;
1694 let mut mutation__ = None;
1695 let mut tracing_context__ = None;
1696 let mut kind__ = None;
1697 while let Some(k) = map_.next_key()? {
1698 match k {
1699 GeneratedField::Epoch => {
1700 if epoch__.is_some() {
1701 return Err(serde::de::Error::duplicate_field("epoch"));
1702 }
1703 epoch__ = map_.next_value()?;
1704 }
1705 GeneratedField::Mutation => {
1706 if mutation__.is_some() {
1707 return Err(serde::de::Error::duplicate_field("mutation"));
1708 }
1709 mutation__ = map_.next_value()?;
1710 }
1711 GeneratedField::TracingContext => {
1712 if tracing_context__.is_some() {
1713 return Err(serde::de::Error::duplicate_field("tracingContext"));
1714 }
1715 tracing_context__ = Some(
1716 map_.next_value::<std::collections::HashMap<_, _>>()?
1717 );
1718 }
1719 GeneratedField::Kind => {
1720 if kind__.is_some() {
1721 return Err(serde::de::Error::duplicate_field("kind"));
1722 }
1723 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1724 }
1725 }
1726 }
1727 Ok(Barrier {
1728 epoch: epoch__,
1729 mutation: mutation__,
1730 tracing_context: tracing_context__.unwrap_or_default(),
1731 kind: kind__.unwrap_or_default(),
1732 })
1733 }
1734 }
1735 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1736 }
1737}
1738impl serde::Serialize for barrier::BarrierKind {
1739 #[allow(deprecated)]
1740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1741 where
1742 S: serde::Serializer,
1743 {
1744 let variant = match self {
1745 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1746 Self::Initial => "BARRIER_KIND_INITIAL",
1747 Self::Barrier => "BARRIER_KIND_BARRIER",
1748 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1749 };
1750 serializer.serialize_str(variant)
1751 }
1752}
1753impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1754 #[allow(deprecated)]
1755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1756 where
1757 D: serde::Deserializer<'de>,
1758 {
1759 const FIELDS: &[&str] = &[
1760 "BARRIER_KIND_UNSPECIFIED",
1761 "BARRIER_KIND_INITIAL",
1762 "BARRIER_KIND_BARRIER",
1763 "BARRIER_KIND_CHECKPOINT",
1764 ];
1765
1766 struct GeneratedVisitor;
1767
1768 impl serde::de::Visitor<'_> for GeneratedVisitor {
1769 type Value = barrier::BarrierKind;
1770
1771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1772 write!(formatter, "expected one of: {:?}", &FIELDS)
1773 }
1774
1775 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1776 where
1777 E: serde::de::Error,
1778 {
1779 i32::try_from(v)
1780 .ok()
1781 .and_then(|x| x.try_into().ok())
1782 .ok_or_else(|| {
1783 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1784 })
1785 }
1786
1787 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1788 where
1789 E: serde::de::Error,
1790 {
1791 i32::try_from(v)
1792 .ok()
1793 .and_then(|x| x.try_into().ok())
1794 .ok_or_else(|| {
1795 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1796 })
1797 }
1798
1799 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1800 where
1801 E: serde::de::Error,
1802 {
1803 match value {
1804 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1805 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1806 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1807 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1808 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1809 }
1810 }
1811 }
1812 deserializer.deserialize_any(GeneratedVisitor)
1813 }
1814}
1815impl serde::Serialize for BarrierMutation {
1816 #[allow(deprecated)]
1817 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1818 where
1819 S: serde::Serializer,
1820 {
1821 use serde::ser::SerializeStruct;
1822 let mut len = 0;
1823 if self.mutation.is_some() {
1824 len += 1;
1825 }
1826 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1827 if let Some(v) = self.mutation.as_ref() {
1828 match v {
1829 barrier_mutation::Mutation::Add(v) => {
1830 struct_ser.serialize_field("add", v)?;
1831 }
1832 barrier_mutation::Mutation::Stop(v) => {
1833 struct_ser.serialize_field("stop", v)?;
1834 }
1835 barrier_mutation::Mutation::Update(v) => {
1836 struct_ser.serialize_field("update", v)?;
1837 }
1838 barrier_mutation::Mutation::Splits(v) => {
1839 struct_ser.serialize_field("splits", v)?;
1840 }
1841 barrier_mutation::Mutation::Pause(v) => {
1842 struct_ser.serialize_field("pause", v)?;
1843 }
1844 barrier_mutation::Mutation::Resume(v) => {
1845 struct_ser.serialize_field("resume", v)?;
1846 }
1847 barrier_mutation::Mutation::Throttle(v) => {
1848 struct_ser.serialize_field("throttle", v)?;
1849 }
1850 barrier_mutation::Mutation::DropSubscriptions(v) => {
1851 struct_ser.serialize_field("dropSubscriptions", v)?;
1852 }
1853 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1854 struct_ser.serialize_field("connectorPropsChange", v)?;
1855 }
1856 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1857 struct_ser.serialize_field("startFragmentBackfill", v)?;
1858 }
1859 barrier_mutation::Mutation::RefreshStart(v) => {
1860 struct_ser.serialize_field("refreshStart", v)?;
1861 }
1862 barrier_mutation::Mutation::LoadFinish(v) => {
1863 struct_ser.serialize_field("loadFinish", v)?;
1864 }
1865 barrier_mutation::Mutation::ListFinish(v) => {
1866 struct_ser.serialize_field("listFinish", v)?;
1867 }
1868 barrier_mutation::Mutation::ResetSource(v) => {
1869 struct_ser.serialize_field("resetSource", v)?;
1870 }
1871 barrier_mutation::Mutation::InjectSourceOffsets(v) => {
1872 struct_ser.serialize_field("injectSourceOffsets", v)?;
1873 }
1874 }
1875 }
1876 struct_ser.end()
1877 }
1878}
1879impl<'de> serde::Deserialize<'de> for BarrierMutation {
1880 #[allow(deprecated)]
1881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1882 where
1883 D: serde::Deserializer<'de>,
1884 {
1885 const FIELDS: &[&str] = &[
1886 "add",
1887 "stop",
1888 "update",
1889 "splits",
1890 "pause",
1891 "resume",
1892 "throttle",
1893 "drop_subscriptions",
1894 "dropSubscriptions",
1895 "connector_props_change",
1896 "connectorPropsChange",
1897 "start_fragment_backfill",
1898 "startFragmentBackfill",
1899 "refresh_start",
1900 "refreshStart",
1901 "load_finish",
1902 "loadFinish",
1903 "list_finish",
1904 "listFinish",
1905 "reset_source",
1906 "resetSource",
1907 "inject_source_offsets",
1908 "injectSourceOffsets",
1909 ];
1910
1911 #[allow(clippy::enum_variant_names)]
1912 enum GeneratedField {
1913 Add,
1914 Stop,
1915 Update,
1916 Splits,
1917 Pause,
1918 Resume,
1919 Throttle,
1920 DropSubscriptions,
1921 ConnectorPropsChange,
1922 StartFragmentBackfill,
1923 RefreshStart,
1924 LoadFinish,
1925 ListFinish,
1926 ResetSource,
1927 InjectSourceOffsets,
1928 }
1929 impl<'de> serde::Deserialize<'de> for GeneratedField {
1930 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1931 where
1932 D: serde::Deserializer<'de>,
1933 {
1934 struct GeneratedVisitor;
1935
1936 impl serde::de::Visitor<'_> for GeneratedVisitor {
1937 type Value = GeneratedField;
1938
1939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1940 write!(formatter, "expected one of: {:?}", &FIELDS)
1941 }
1942
1943 #[allow(unused_variables)]
1944 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1945 where
1946 E: serde::de::Error,
1947 {
1948 match value {
1949 "add" => Ok(GeneratedField::Add),
1950 "stop" => Ok(GeneratedField::Stop),
1951 "update" => Ok(GeneratedField::Update),
1952 "splits" => Ok(GeneratedField::Splits),
1953 "pause" => Ok(GeneratedField::Pause),
1954 "resume" => Ok(GeneratedField::Resume),
1955 "throttle" => Ok(GeneratedField::Throttle),
1956 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1957 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1958 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1959 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1960 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1961 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1962 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1963 "injectSourceOffsets" | "inject_source_offsets" => Ok(GeneratedField::InjectSourceOffsets),
1964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1965 }
1966 }
1967 }
1968 deserializer.deserialize_identifier(GeneratedVisitor)
1969 }
1970 }
1971 struct GeneratedVisitor;
1972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1973 type Value = BarrierMutation;
1974
1975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1976 formatter.write_str("struct stream_plan.BarrierMutation")
1977 }
1978
1979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1980 where
1981 V: serde::de::MapAccess<'de>,
1982 {
1983 let mut mutation__ = None;
1984 while let Some(k) = map_.next_key()? {
1985 match k {
1986 GeneratedField::Add => {
1987 if mutation__.is_some() {
1988 return Err(serde::de::Error::duplicate_field("add"));
1989 }
1990 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1991;
1992 }
1993 GeneratedField::Stop => {
1994 if mutation__.is_some() {
1995 return Err(serde::de::Error::duplicate_field("stop"));
1996 }
1997 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1998;
1999 }
2000 GeneratedField::Update => {
2001 if mutation__.is_some() {
2002 return Err(serde::de::Error::duplicate_field("update"));
2003 }
2004 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
2005;
2006 }
2007 GeneratedField::Splits => {
2008 if mutation__.is_some() {
2009 return Err(serde::de::Error::duplicate_field("splits"));
2010 }
2011 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
2012;
2013 }
2014 GeneratedField::Pause => {
2015 if mutation__.is_some() {
2016 return Err(serde::de::Error::duplicate_field("pause"));
2017 }
2018 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
2019;
2020 }
2021 GeneratedField::Resume => {
2022 if mutation__.is_some() {
2023 return Err(serde::de::Error::duplicate_field("resume"));
2024 }
2025 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
2026;
2027 }
2028 GeneratedField::Throttle => {
2029 if mutation__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("throttle"));
2031 }
2032 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
2033;
2034 }
2035 GeneratedField::DropSubscriptions => {
2036 if mutation__.is_some() {
2037 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
2038 }
2039 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
2040;
2041 }
2042 GeneratedField::ConnectorPropsChange => {
2043 if mutation__.is_some() {
2044 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
2045 }
2046 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
2047;
2048 }
2049 GeneratedField::StartFragmentBackfill => {
2050 if mutation__.is_some() {
2051 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
2052 }
2053 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
2054;
2055 }
2056 GeneratedField::RefreshStart => {
2057 if mutation__.is_some() {
2058 return Err(serde::de::Error::duplicate_field("refreshStart"));
2059 }
2060 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2061;
2062 }
2063 GeneratedField::LoadFinish => {
2064 if mutation__.is_some() {
2065 return Err(serde::de::Error::duplicate_field("loadFinish"));
2066 }
2067 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2068;
2069 }
2070 GeneratedField::ListFinish => {
2071 if mutation__.is_some() {
2072 return Err(serde::de::Error::duplicate_field("listFinish"));
2073 }
2074 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2075;
2076 }
2077 GeneratedField::ResetSource => {
2078 if mutation__.is_some() {
2079 return Err(serde::de::Error::duplicate_field("resetSource"));
2080 }
2081 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2082;
2083 }
2084 GeneratedField::InjectSourceOffsets => {
2085 if mutation__.is_some() {
2086 return Err(serde::de::Error::duplicate_field("injectSourceOffsets"));
2087 }
2088 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::InjectSourceOffsets)
2089;
2090 }
2091 }
2092 }
2093 Ok(BarrierMutation {
2094 mutation: mutation__,
2095 })
2096 }
2097 }
2098 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2099 }
2100}
2101impl serde::Serialize for BarrierRecvNode {
2102 #[allow(deprecated)]
2103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2104 where
2105 S: serde::Serializer,
2106 {
2107 use serde::ser::SerializeStruct;
2108 let len = 0;
2109 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2110 struct_ser.end()
2111 }
2112}
2113impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2114 #[allow(deprecated)]
2115 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2116 where
2117 D: serde::Deserializer<'de>,
2118 {
2119 const FIELDS: &[&str] = &[
2120 ];
2121
2122 #[allow(clippy::enum_variant_names)]
2123 enum GeneratedField {
2124 }
2125 impl<'de> serde::Deserialize<'de> for GeneratedField {
2126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2127 where
2128 D: serde::Deserializer<'de>,
2129 {
2130 struct GeneratedVisitor;
2131
2132 impl serde::de::Visitor<'_> for GeneratedVisitor {
2133 type Value = GeneratedField;
2134
2135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2136 write!(formatter, "expected one of: {:?}", &FIELDS)
2137 }
2138
2139 #[allow(unused_variables)]
2140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2141 where
2142 E: serde::de::Error,
2143 {
2144 Err(serde::de::Error::unknown_field(value, FIELDS))
2145 }
2146 }
2147 deserializer.deserialize_identifier(GeneratedVisitor)
2148 }
2149 }
2150 struct GeneratedVisitor;
2151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2152 type Value = BarrierRecvNode;
2153
2154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2155 formatter.write_str("struct stream_plan.BarrierRecvNode")
2156 }
2157
2158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2159 where
2160 V: serde::de::MapAccess<'de>,
2161 {
2162 while map_.next_key::<GeneratedField>()?.is_some() {
2163 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2164 }
2165 Ok(BarrierRecvNode {
2166 })
2167 }
2168 }
2169 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2170 }
2171}
2172impl serde::Serialize for BatchPlanNode {
2173 #[allow(deprecated)]
2174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2175 where
2176 S: serde::Serializer,
2177 {
2178 use serde::ser::SerializeStruct;
2179 let mut len = 0;
2180 if self.table_desc.is_some() {
2181 len += 1;
2182 }
2183 if !self.column_ids.is_empty() {
2184 len += 1;
2185 }
2186 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2187 if let Some(v) = self.table_desc.as_ref() {
2188 struct_ser.serialize_field("tableDesc", v)?;
2189 }
2190 if !self.column_ids.is_empty() {
2191 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2192 }
2193 struct_ser.end()
2194 }
2195}
2196impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2197 #[allow(deprecated)]
2198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2199 where
2200 D: serde::Deserializer<'de>,
2201 {
2202 const FIELDS: &[&str] = &[
2203 "table_desc",
2204 "tableDesc",
2205 "column_ids",
2206 "columnIds",
2207 ];
2208
2209 #[allow(clippy::enum_variant_names)]
2210 enum GeneratedField {
2211 TableDesc,
2212 ColumnIds,
2213 }
2214 impl<'de> serde::Deserialize<'de> for GeneratedField {
2215 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2216 where
2217 D: serde::Deserializer<'de>,
2218 {
2219 struct GeneratedVisitor;
2220
2221 impl serde::de::Visitor<'_> for GeneratedVisitor {
2222 type Value = GeneratedField;
2223
2224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2225 write!(formatter, "expected one of: {:?}", &FIELDS)
2226 }
2227
2228 #[allow(unused_variables)]
2229 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2230 where
2231 E: serde::de::Error,
2232 {
2233 match value {
2234 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2235 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2236 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2237 }
2238 }
2239 }
2240 deserializer.deserialize_identifier(GeneratedVisitor)
2241 }
2242 }
2243 struct GeneratedVisitor;
2244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2245 type Value = BatchPlanNode;
2246
2247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2248 formatter.write_str("struct stream_plan.BatchPlanNode")
2249 }
2250
2251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2252 where
2253 V: serde::de::MapAccess<'de>,
2254 {
2255 let mut table_desc__ = None;
2256 let mut column_ids__ = None;
2257 while let Some(k) = map_.next_key()? {
2258 match k {
2259 GeneratedField::TableDesc => {
2260 if table_desc__.is_some() {
2261 return Err(serde::de::Error::duplicate_field("tableDesc"));
2262 }
2263 table_desc__ = map_.next_value()?;
2264 }
2265 GeneratedField::ColumnIds => {
2266 if column_ids__.is_some() {
2267 return Err(serde::de::Error::duplicate_field("columnIds"));
2268 }
2269 column_ids__ =
2270 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2271 .into_iter().map(|x| x.0).collect())
2272 ;
2273 }
2274 }
2275 }
2276 Ok(BatchPlanNode {
2277 table_desc: table_desc__,
2278 column_ids: column_ids__.unwrap_or_default(),
2279 })
2280 }
2281 }
2282 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2283 }
2284}
2285impl serde::Serialize for CdcFilterNode {
2286 #[allow(deprecated)]
2287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2288 where
2289 S: serde::Serializer,
2290 {
2291 use serde::ser::SerializeStruct;
2292 let mut len = 0;
2293 if self.search_condition.is_some() {
2294 len += 1;
2295 }
2296 if self.upstream_source_id != 0 {
2297 len += 1;
2298 }
2299 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2300 if let Some(v) = self.search_condition.as_ref() {
2301 struct_ser.serialize_field("searchCondition", v)?;
2302 }
2303 if self.upstream_source_id != 0 {
2304 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2305 }
2306 struct_ser.end()
2307 }
2308}
2309impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2310 #[allow(deprecated)]
2311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2312 where
2313 D: serde::Deserializer<'de>,
2314 {
2315 const FIELDS: &[&str] = &[
2316 "search_condition",
2317 "searchCondition",
2318 "upstream_source_id",
2319 "upstreamSourceId",
2320 ];
2321
2322 #[allow(clippy::enum_variant_names)]
2323 enum GeneratedField {
2324 SearchCondition,
2325 UpstreamSourceId,
2326 }
2327 impl<'de> serde::Deserialize<'de> for GeneratedField {
2328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2329 where
2330 D: serde::Deserializer<'de>,
2331 {
2332 struct GeneratedVisitor;
2333
2334 impl serde::de::Visitor<'_> for GeneratedVisitor {
2335 type Value = GeneratedField;
2336
2337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2338 write!(formatter, "expected one of: {:?}", &FIELDS)
2339 }
2340
2341 #[allow(unused_variables)]
2342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2343 where
2344 E: serde::de::Error,
2345 {
2346 match value {
2347 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2348 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2350 }
2351 }
2352 }
2353 deserializer.deserialize_identifier(GeneratedVisitor)
2354 }
2355 }
2356 struct GeneratedVisitor;
2357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2358 type Value = CdcFilterNode;
2359
2360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2361 formatter.write_str("struct stream_plan.CdcFilterNode")
2362 }
2363
2364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2365 where
2366 V: serde::de::MapAccess<'de>,
2367 {
2368 let mut search_condition__ = None;
2369 let mut upstream_source_id__ = None;
2370 while let Some(k) = map_.next_key()? {
2371 match k {
2372 GeneratedField::SearchCondition => {
2373 if search_condition__.is_some() {
2374 return Err(serde::de::Error::duplicate_field("searchCondition"));
2375 }
2376 search_condition__ = map_.next_value()?;
2377 }
2378 GeneratedField::UpstreamSourceId => {
2379 if upstream_source_id__.is_some() {
2380 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2381 }
2382 upstream_source_id__ =
2383 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2384 ;
2385 }
2386 }
2387 }
2388 Ok(CdcFilterNode {
2389 search_condition: search_condition__,
2390 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2391 })
2392 }
2393 }
2394 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2395 }
2396}
2397impl serde::Serialize for ChangeLogNode {
2398 #[allow(deprecated)]
2399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2400 where
2401 S: serde::Serializer,
2402 {
2403 use serde::ser::SerializeStruct;
2404 let mut len = 0;
2405 if self.need_op {
2406 len += 1;
2407 }
2408 if !self.distribution_keys.is_empty() {
2409 len += 1;
2410 }
2411 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2412 if self.need_op {
2413 struct_ser.serialize_field("needOp", &self.need_op)?;
2414 }
2415 if !self.distribution_keys.is_empty() {
2416 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2417 }
2418 struct_ser.end()
2419 }
2420}
2421impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2422 #[allow(deprecated)]
2423 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2424 where
2425 D: serde::Deserializer<'de>,
2426 {
2427 const FIELDS: &[&str] = &[
2428 "need_op",
2429 "needOp",
2430 "distribution_keys",
2431 "distributionKeys",
2432 ];
2433
2434 #[allow(clippy::enum_variant_names)]
2435 enum GeneratedField {
2436 NeedOp,
2437 DistributionKeys,
2438 }
2439 impl<'de> serde::Deserialize<'de> for GeneratedField {
2440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2441 where
2442 D: serde::Deserializer<'de>,
2443 {
2444 struct GeneratedVisitor;
2445
2446 impl serde::de::Visitor<'_> for GeneratedVisitor {
2447 type Value = GeneratedField;
2448
2449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2450 write!(formatter, "expected one of: {:?}", &FIELDS)
2451 }
2452
2453 #[allow(unused_variables)]
2454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2455 where
2456 E: serde::de::Error,
2457 {
2458 match value {
2459 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2460 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2461 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2462 }
2463 }
2464 }
2465 deserializer.deserialize_identifier(GeneratedVisitor)
2466 }
2467 }
2468 struct GeneratedVisitor;
2469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2470 type Value = ChangeLogNode;
2471
2472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2473 formatter.write_str("struct stream_plan.ChangeLogNode")
2474 }
2475
2476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2477 where
2478 V: serde::de::MapAccess<'de>,
2479 {
2480 let mut need_op__ = None;
2481 let mut distribution_keys__ = None;
2482 while let Some(k) = map_.next_key()? {
2483 match k {
2484 GeneratedField::NeedOp => {
2485 if need_op__.is_some() {
2486 return Err(serde::de::Error::duplicate_field("needOp"));
2487 }
2488 need_op__ = Some(map_.next_value()?);
2489 }
2490 GeneratedField::DistributionKeys => {
2491 if distribution_keys__.is_some() {
2492 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2493 }
2494 distribution_keys__ =
2495 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2496 .into_iter().map(|x| x.0).collect())
2497 ;
2498 }
2499 }
2500 }
2501 Ok(ChangeLogNode {
2502 need_op: need_op__.unwrap_or_default(),
2503 distribution_keys: distribution_keys__.unwrap_or_default(),
2504 })
2505 }
2506 }
2507 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2508 }
2509}
2510impl serde::Serialize for Columns {
2511 #[allow(deprecated)]
2512 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2513 where
2514 S: serde::Serializer,
2515 {
2516 use serde::ser::SerializeStruct;
2517 let mut len = 0;
2518 if !self.columns.is_empty() {
2519 len += 1;
2520 }
2521 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2522 if !self.columns.is_empty() {
2523 struct_ser.serialize_field("columns", &self.columns)?;
2524 }
2525 struct_ser.end()
2526 }
2527}
2528impl<'de> serde::Deserialize<'de> for Columns {
2529 #[allow(deprecated)]
2530 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2531 where
2532 D: serde::Deserializer<'de>,
2533 {
2534 const FIELDS: &[&str] = &[
2535 "columns",
2536 ];
2537
2538 #[allow(clippy::enum_variant_names)]
2539 enum GeneratedField {
2540 Columns,
2541 }
2542 impl<'de> serde::Deserialize<'de> for GeneratedField {
2543 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2544 where
2545 D: serde::Deserializer<'de>,
2546 {
2547 struct GeneratedVisitor;
2548
2549 impl serde::de::Visitor<'_> for GeneratedVisitor {
2550 type Value = GeneratedField;
2551
2552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2553 write!(formatter, "expected one of: {:?}", &FIELDS)
2554 }
2555
2556 #[allow(unused_variables)]
2557 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2558 where
2559 E: serde::de::Error,
2560 {
2561 match value {
2562 "columns" => Ok(GeneratedField::Columns),
2563 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2564 }
2565 }
2566 }
2567 deserializer.deserialize_identifier(GeneratedVisitor)
2568 }
2569 }
2570 struct GeneratedVisitor;
2571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2572 type Value = Columns;
2573
2574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2575 formatter.write_str("struct stream_plan.Columns")
2576 }
2577
2578 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2579 where
2580 V: serde::de::MapAccess<'de>,
2581 {
2582 let mut columns__ = None;
2583 while let Some(k) = map_.next_key()? {
2584 match k {
2585 GeneratedField::Columns => {
2586 if columns__.is_some() {
2587 return Err(serde::de::Error::duplicate_field("columns"));
2588 }
2589 columns__ = Some(map_.next_value()?);
2590 }
2591 }
2592 }
2593 Ok(Columns {
2594 columns: columns__.unwrap_or_default(),
2595 })
2596 }
2597 }
2598 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2599 }
2600}
2601impl serde::Serialize for CompactionResolverNode {
2602 #[allow(deprecated)]
2603 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2604 where
2605 S: serde::Serializer,
2606 {
2607 use serde::ser::SerializeStruct;
2608 let mut len = 0;
2609 if self.sink_id != 0 {
2610 len += 1;
2611 }
2612 if !self.properties.is_empty() {
2613 len += 1;
2614 }
2615 if !self.secret_refs.is_empty() {
2616 len += 1;
2617 }
2618 if !self.pk_columns.is_empty() {
2619 len += 1;
2620 }
2621 let mut struct_ser = serializer.serialize_struct("stream_plan.CompactionResolverNode", len)?;
2622 if self.sink_id != 0 {
2623 struct_ser.serialize_field("sinkId", &self.sink_id)?;
2624 }
2625 if !self.properties.is_empty() {
2626 struct_ser.serialize_field("properties", &self.properties)?;
2627 }
2628 if !self.secret_refs.is_empty() {
2629 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
2630 }
2631 if !self.pk_columns.is_empty() {
2632 struct_ser.serialize_field("pkColumns", &self.pk_columns)?;
2633 }
2634 struct_ser.end()
2635 }
2636}
2637impl<'de> serde::Deserialize<'de> for CompactionResolverNode {
2638 #[allow(deprecated)]
2639 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2640 where
2641 D: serde::Deserializer<'de>,
2642 {
2643 const FIELDS: &[&str] = &[
2644 "sink_id",
2645 "sinkId",
2646 "properties",
2647 "secret_refs",
2648 "secretRefs",
2649 "pk_columns",
2650 "pkColumns",
2651 ];
2652
2653 #[allow(clippy::enum_variant_names)]
2654 enum GeneratedField {
2655 SinkId,
2656 Properties,
2657 SecretRefs,
2658 PkColumns,
2659 }
2660 impl<'de> serde::Deserialize<'de> for GeneratedField {
2661 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2662 where
2663 D: serde::Deserializer<'de>,
2664 {
2665 struct GeneratedVisitor;
2666
2667 impl serde::de::Visitor<'_> for GeneratedVisitor {
2668 type Value = GeneratedField;
2669
2670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2671 write!(formatter, "expected one of: {:?}", &FIELDS)
2672 }
2673
2674 #[allow(unused_variables)]
2675 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2676 where
2677 E: serde::de::Error,
2678 {
2679 match value {
2680 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2681 "properties" => Ok(GeneratedField::Properties),
2682 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
2683 "pkColumns" | "pk_columns" => Ok(GeneratedField::PkColumns),
2684 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2685 }
2686 }
2687 }
2688 deserializer.deserialize_identifier(GeneratedVisitor)
2689 }
2690 }
2691 struct GeneratedVisitor;
2692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2693 type Value = CompactionResolverNode;
2694
2695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2696 formatter.write_str("struct stream_plan.CompactionResolverNode")
2697 }
2698
2699 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionResolverNode, V::Error>
2700 where
2701 V: serde::de::MapAccess<'de>,
2702 {
2703 let mut sink_id__ = None;
2704 let mut properties__ = None;
2705 let mut secret_refs__ = None;
2706 let mut pk_columns__ = None;
2707 while let Some(k) = map_.next_key()? {
2708 match k {
2709 GeneratedField::SinkId => {
2710 if sink_id__.is_some() {
2711 return Err(serde::de::Error::duplicate_field("sinkId"));
2712 }
2713 sink_id__ =
2714 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2715 ;
2716 }
2717 GeneratedField::Properties => {
2718 if properties__.is_some() {
2719 return Err(serde::de::Error::duplicate_field("properties"));
2720 }
2721 properties__ = Some(
2722 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2723 );
2724 }
2725 GeneratedField::SecretRefs => {
2726 if secret_refs__.is_some() {
2727 return Err(serde::de::Error::duplicate_field("secretRefs"));
2728 }
2729 secret_refs__ = Some(
2730 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2731 );
2732 }
2733 GeneratedField::PkColumns => {
2734 if pk_columns__.is_some() {
2735 return Err(serde::de::Error::duplicate_field("pkColumns"));
2736 }
2737 pk_columns__ = Some(map_.next_value()?);
2738 }
2739 }
2740 }
2741 Ok(CompactionResolverNode {
2742 sink_id: sink_id__.unwrap_or_default(),
2743 properties: properties__.unwrap_or_default(),
2744 secret_refs: secret_refs__.unwrap_or_default(),
2745 pk_columns: pk_columns__.unwrap_or_default(),
2746 })
2747 }
2748 }
2749 deserializer.deserialize_struct("stream_plan.CompactionResolverNode", FIELDS, GeneratedVisitor)
2750 }
2751}
2752impl serde::Serialize for compaction_resolver_node::PkColumn {
2753 #[allow(deprecated)]
2754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2755 where
2756 S: serde::Serializer,
2757 {
2758 use serde::ser::SerializeStruct;
2759 let mut len = 0;
2760 if self.data_file_index != 0 {
2761 len += 1;
2762 }
2763 if self.column_desc.is_some() {
2764 len += 1;
2765 }
2766 let mut struct_ser = serializer.serialize_struct("stream_plan.CompactionResolverNode.PkColumn", len)?;
2767 if self.data_file_index != 0 {
2768 struct_ser.serialize_field("dataFileIndex", &self.data_file_index)?;
2769 }
2770 if let Some(v) = self.column_desc.as_ref() {
2771 struct_ser.serialize_field("columnDesc", v)?;
2772 }
2773 struct_ser.end()
2774 }
2775}
2776impl<'de> serde::Deserialize<'de> for compaction_resolver_node::PkColumn {
2777 #[allow(deprecated)]
2778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2779 where
2780 D: serde::Deserializer<'de>,
2781 {
2782 const FIELDS: &[&str] = &[
2783 "data_file_index",
2784 "dataFileIndex",
2785 "column_desc",
2786 "columnDesc",
2787 ];
2788
2789 #[allow(clippy::enum_variant_names)]
2790 enum GeneratedField {
2791 DataFileIndex,
2792 ColumnDesc,
2793 }
2794 impl<'de> serde::Deserialize<'de> for GeneratedField {
2795 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2796 where
2797 D: serde::Deserializer<'de>,
2798 {
2799 struct GeneratedVisitor;
2800
2801 impl serde::de::Visitor<'_> for GeneratedVisitor {
2802 type Value = GeneratedField;
2803
2804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2805 write!(formatter, "expected one of: {:?}", &FIELDS)
2806 }
2807
2808 #[allow(unused_variables)]
2809 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2810 where
2811 E: serde::de::Error,
2812 {
2813 match value {
2814 "dataFileIndex" | "data_file_index" => Ok(GeneratedField::DataFileIndex),
2815 "columnDesc" | "column_desc" => Ok(GeneratedField::ColumnDesc),
2816 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2817 }
2818 }
2819 }
2820 deserializer.deserialize_identifier(GeneratedVisitor)
2821 }
2822 }
2823 struct GeneratedVisitor;
2824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2825 type Value = compaction_resolver_node::PkColumn;
2826
2827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2828 formatter.write_str("struct stream_plan.CompactionResolverNode.PkColumn")
2829 }
2830
2831 fn visit_map<V>(self, mut map_: V) -> std::result::Result<compaction_resolver_node::PkColumn, V::Error>
2832 where
2833 V: serde::de::MapAccess<'de>,
2834 {
2835 let mut data_file_index__ = None;
2836 let mut column_desc__ = None;
2837 while let Some(k) = map_.next_key()? {
2838 match k {
2839 GeneratedField::DataFileIndex => {
2840 if data_file_index__.is_some() {
2841 return Err(serde::de::Error::duplicate_field("dataFileIndex"));
2842 }
2843 data_file_index__ =
2844 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2845 ;
2846 }
2847 GeneratedField::ColumnDesc => {
2848 if column_desc__.is_some() {
2849 return Err(serde::de::Error::duplicate_field("columnDesc"));
2850 }
2851 column_desc__ = map_.next_value()?;
2852 }
2853 }
2854 }
2855 Ok(compaction_resolver_node::PkColumn {
2856 data_file_index: data_file_index__.unwrap_or_default(),
2857 column_desc: column_desc__,
2858 })
2859 }
2860 }
2861 deserializer.deserialize_struct("stream_plan.CompactionResolverNode.PkColumn", FIELDS, GeneratedVisitor)
2862 }
2863}
2864impl serde::Serialize for ConnectorPropsChangeMutation {
2865 #[allow(deprecated)]
2866 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2867 where
2868 S: serde::Serializer,
2869 {
2870 use serde::ser::SerializeStruct;
2871 let mut len = 0;
2872 if !self.connector_props_infos.is_empty() {
2873 len += 1;
2874 }
2875 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2876 if !self.connector_props_infos.is_empty() {
2877 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2878 }
2879 struct_ser.end()
2880 }
2881}
2882impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2883 #[allow(deprecated)]
2884 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2885 where
2886 D: serde::Deserializer<'de>,
2887 {
2888 const FIELDS: &[&str] = &[
2889 "connector_props_infos",
2890 "connectorPropsInfos",
2891 ];
2892
2893 #[allow(clippy::enum_variant_names)]
2894 enum GeneratedField {
2895 ConnectorPropsInfos,
2896 }
2897 impl<'de> serde::Deserialize<'de> for GeneratedField {
2898 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2899 where
2900 D: serde::Deserializer<'de>,
2901 {
2902 struct GeneratedVisitor;
2903
2904 impl serde::de::Visitor<'_> for GeneratedVisitor {
2905 type Value = GeneratedField;
2906
2907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2908 write!(formatter, "expected one of: {:?}", &FIELDS)
2909 }
2910
2911 #[allow(unused_variables)]
2912 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2913 where
2914 E: serde::de::Error,
2915 {
2916 match value {
2917 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2918 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2919 }
2920 }
2921 }
2922 deserializer.deserialize_identifier(GeneratedVisitor)
2923 }
2924 }
2925 struct GeneratedVisitor;
2926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2927 type Value = ConnectorPropsChangeMutation;
2928
2929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2930 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2931 }
2932
2933 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2934 where
2935 V: serde::de::MapAccess<'de>,
2936 {
2937 let mut connector_props_infos__ = None;
2938 while let Some(k) = map_.next_key()? {
2939 match k {
2940 GeneratedField::ConnectorPropsInfos => {
2941 if connector_props_infos__.is_some() {
2942 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2943 }
2944 connector_props_infos__ = Some(
2945 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2946 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2947 );
2948 }
2949 }
2950 }
2951 Ok(ConnectorPropsChangeMutation {
2952 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2953 })
2954 }
2955 }
2956 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2957 }
2958}
2959impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2960 #[allow(deprecated)]
2961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2962 where
2963 S: serde::Serializer,
2964 {
2965 use serde::ser::SerializeStruct;
2966 let mut len = 0;
2967 if !self.connector_props_info.is_empty() {
2968 len += 1;
2969 }
2970 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2971 if !self.connector_props_info.is_empty() {
2972 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2973 }
2974 struct_ser.end()
2975 }
2976}
2977impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2978 #[allow(deprecated)]
2979 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2980 where
2981 D: serde::Deserializer<'de>,
2982 {
2983 const FIELDS: &[&str] = &[
2984 "connector_props_info",
2985 "connectorPropsInfo",
2986 ];
2987
2988 #[allow(clippy::enum_variant_names)]
2989 enum GeneratedField {
2990 ConnectorPropsInfo,
2991 }
2992 impl<'de> serde::Deserialize<'de> for GeneratedField {
2993 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2994 where
2995 D: serde::Deserializer<'de>,
2996 {
2997 struct GeneratedVisitor;
2998
2999 impl serde::de::Visitor<'_> for GeneratedVisitor {
3000 type Value = GeneratedField;
3001
3002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3003 write!(formatter, "expected one of: {:?}", &FIELDS)
3004 }
3005
3006 #[allow(unused_variables)]
3007 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3008 where
3009 E: serde::de::Error,
3010 {
3011 match value {
3012 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
3013 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3014 }
3015 }
3016 }
3017 deserializer.deserialize_identifier(GeneratedVisitor)
3018 }
3019 }
3020 struct GeneratedVisitor;
3021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3022 type Value = connector_props_change_mutation::ConnectorPropsInfo;
3023
3024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3025 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
3026 }
3027
3028 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
3029 where
3030 V: serde::de::MapAccess<'de>,
3031 {
3032 let mut connector_props_info__ = None;
3033 while let Some(k) = map_.next_key()? {
3034 match k {
3035 GeneratedField::ConnectorPropsInfo => {
3036 if connector_props_info__.is_some() {
3037 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
3038 }
3039 connector_props_info__ = Some(
3040 map_.next_value::<std::collections::HashMap<_, _>>()?
3041 );
3042 }
3043 }
3044 }
3045 Ok(connector_props_change_mutation::ConnectorPropsInfo {
3046 connector_props_info: connector_props_info__.unwrap_or_default(),
3047 })
3048 }
3049 }
3050 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
3051 }
3052}
3053impl serde::Serialize for DedupNode {
3054 #[allow(deprecated)]
3055 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3056 where
3057 S: serde::Serializer,
3058 {
3059 use serde::ser::SerializeStruct;
3060 let mut len = 0;
3061 if self.state_table.is_some() {
3062 len += 1;
3063 }
3064 if !self.dedup_column_indices.is_empty() {
3065 len += 1;
3066 }
3067 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
3068 if let Some(v) = self.state_table.as_ref() {
3069 struct_ser.serialize_field("stateTable", v)?;
3070 }
3071 if !self.dedup_column_indices.is_empty() {
3072 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
3073 }
3074 struct_ser.end()
3075 }
3076}
3077impl<'de> serde::Deserialize<'de> for DedupNode {
3078 #[allow(deprecated)]
3079 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3080 where
3081 D: serde::Deserializer<'de>,
3082 {
3083 const FIELDS: &[&str] = &[
3084 "state_table",
3085 "stateTable",
3086 "dedup_column_indices",
3087 "dedupColumnIndices",
3088 ];
3089
3090 #[allow(clippy::enum_variant_names)]
3091 enum GeneratedField {
3092 StateTable,
3093 DedupColumnIndices,
3094 }
3095 impl<'de> serde::Deserialize<'de> for GeneratedField {
3096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3097 where
3098 D: serde::Deserializer<'de>,
3099 {
3100 struct GeneratedVisitor;
3101
3102 impl serde::de::Visitor<'_> for GeneratedVisitor {
3103 type Value = GeneratedField;
3104
3105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3106 write!(formatter, "expected one of: {:?}", &FIELDS)
3107 }
3108
3109 #[allow(unused_variables)]
3110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3111 where
3112 E: serde::de::Error,
3113 {
3114 match value {
3115 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
3116 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
3117 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3118 }
3119 }
3120 }
3121 deserializer.deserialize_identifier(GeneratedVisitor)
3122 }
3123 }
3124 struct GeneratedVisitor;
3125 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3126 type Value = DedupNode;
3127
3128 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3129 formatter.write_str("struct stream_plan.DedupNode")
3130 }
3131
3132 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
3133 where
3134 V: serde::de::MapAccess<'de>,
3135 {
3136 let mut state_table__ = None;
3137 let mut dedup_column_indices__ = None;
3138 while let Some(k) = map_.next_key()? {
3139 match k {
3140 GeneratedField::StateTable => {
3141 if state_table__.is_some() {
3142 return Err(serde::de::Error::duplicate_field("stateTable"));
3143 }
3144 state_table__ = map_.next_value()?;
3145 }
3146 GeneratedField::DedupColumnIndices => {
3147 if dedup_column_indices__.is_some() {
3148 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
3149 }
3150 dedup_column_indices__ =
3151 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3152 .into_iter().map(|x| x.0).collect())
3153 ;
3154 }
3155 }
3156 }
3157 Ok(DedupNode {
3158 state_table: state_table__,
3159 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
3160 })
3161 }
3162 }
3163 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
3164 }
3165}
3166impl serde::Serialize for DeltaExpression {
3167 #[allow(deprecated)]
3168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3169 where
3170 S: serde::Serializer,
3171 {
3172 use serde::ser::SerializeStruct;
3173 let mut len = 0;
3174 if self.delta_type != 0 {
3175 len += 1;
3176 }
3177 if self.delta.is_some() {
3178 len += 1;
3179 }
3180 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
3181 if self.delta_type != 0 {
3182 let v = super::expr::expr_node::Type::try_from(self.delta_type)
3183 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
3184 struct_ser.serialize_field("deltaType", &v)?;
3185 }
3186 if let Some(v) = self.delta.as_ref() {
3187 struct_ser.serialize_field("delta", v)?;
3188 }
3189 struct_ser.end()
3190 }
3191}
3192impl<'de> serde::Deserialize<'de> for DeltaExpression {
3193 #[allow(deprecated)]
3194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3195 where
3196 D: serde::Deserializer<'de>,
3197 {
3198 const FIELDS: &[&str] = &[
3199 "delta_type",
3200 "deltaType",
3201 "delta",
3202 ];
3203
3204 #[allow(clippy::enum_variant_names)]
3205 enum GeneratedField {
3206 DeltaType,
3207 Delta,
3208 }
3209 impl<'de> serde::Deserialize<'de> for GeneratedField {
3210 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3211 where
3212 D: serde::Deserializer<'de>,
3213 {
3214 struct GeneratedVisitor;
3215
3216 impl serde::de::Visitor<'_> for GeneratedVisitor {
3217 type Value = GeneratedField;
3218
3219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3220 write!(formatter, "expected one of: {:?}", &FIELDS)
3221 }
3222
3223 #[allow(unused_variables)]
3224 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3225 where
3226 E: serde::de::Error,
3227 {
3228 match value {
3229 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
3230 "delta" => Ok(GeneratedField::Delta),
3231 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3232 }
3233 }
3234 }
3235 deserializer.deserialize_identifier(GeneratedVisitor)
3236 }
3237 }
3238 struct GeneratedVisitor;
3239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3240 type Value = DeltaExpression;
3241
3242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3243 formatter.write_str("struct stream_plan.DeltaExpression")
3244 }
3245
3246 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
3247 where
3248 V: serde::de::MapAccess<'de>,
3249 {
3250 let mut delta_type__ = None;
3251 let mut delta__ = None;
3252 while let Some(k) = map_.next_key()? {
3253 match k {
3254 GeneratedField::DeltaType => {
3255 if delta_type__.is_some() {
3256 return Err(serde::de::Error::duplicate_field("deltaType"));
3257 }
3258 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
3259 }
3260 GeneratedField::Delta => {
3261 if delta__.is_some() {
3262 return Err(serde::de::Error::duplicate_field("delta"));
3263 }
3264 delta__ = map_.next_value()?;
3265 }
3266 }
3267 }
3268 Ok(DeltaExpression {
3269 delta_type: delta_type__.unwrap_or_default(),
3270 delta: delta__,
3271 })
3272 }
3273 }
3274 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
3275 }
3276}
3277impl serde::Serialize for DeltaIndexJoinNode {
3278 #[allow(deprecated)]
3279 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3280 where
3281 S: serde::Serializer,
3282 {
3283 use serde::ser::SerializeStruct;
3284 let mut len = 0;
3285 if self.join_type != 0 {
3286 len += 1;
3287 }
3288 if !self.left_key.is_empty() {
3289 len += 1;
3290 }
3291 if !self.right_key.is_empty() {
3292 len += 1;
3293 }
3294 if self.condition.is_some() {
3295 len += 1;
3296 }
3297 if self.left_table_id != 0 {
3298 len += 1;
3299 }
3300 if self.right_table_id != 0 {
3301 len += 1;
3302 }
3303 if self.left_info.is_some() {
3304 len += 1;
3305 }
3306 if self.right_info.is_some() {
3307 len += 1;
3308 }
3309 if !self.output_indices.is_empty() {
3310 len += 1;
3311 }
3312 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
3313 if self.join_type != 0 {
3314 let v = super::plan_common::JoinType::try_from(self.join_type)
3315 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3316 struct_ser.serialize_field("joinType", &v)?;
3317 }
3318 if !self.left_key.is_empty() {
3319 struct_ser.serialize_field("leftKey", &self.left_key)?;
3320 }
3321 if !self.right_key.is_empty() {
3322 struct_ser.serialize_field("rightKey", &self.right_key)?;
3323 }
3324 if let Some(v) = self.condition.as_ref() {
3325 struct_ser.serialize_field("condition", v)?;
3326 }
3327 if self.left_table_id != 0 {
3328 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3329 }
3330 if self.right_table_id != 0 {
3331 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3332 }
3333 if let Some(v) = self.left_info.as_ref() {
3334 struct_ser.serialize_field("leftInfo", v)?;
3335 }
3336 if let Some(v) = self.right_info.as_ref() {
3337 struct_ser.serialize_field("rightInfo", v)?;
3338 }
3339 if !self.output_indices.is_empty() {
3340 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3341 }
3342 struct_ser.end()
3343 }
3344}
3345impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3346 #[allow(deprecated)]
3347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3348 where
3349 D: serde::Deserializer<'de>,
3350 {
3351 const FIELDS: &[&str] = &[
3352 "join_type",
3353 "joinType",
3354 "left_key",
3355 "leftKey",
3356 "right_key",
3357 "rightKey",
3358 "condition",
3359 "left_table_id",
3360 "leftTableId",
3361 "right_table_id",
3362 "rightTableId",
3363 "left_info",
3364 "leftInfo",
3365 "right_info",
3366 "rightInfo",
3367 "output_indices",
3368 "outputIndices",
3369 ];
3370
3371 #[allow(clippy::enum_variant_names)]
3372 enum GeneratedField {
3373 JoinType,
3374 LeftKey,
3375 RightKey,
3376 Condition,
3377 LeftTableId,
3378 RightTableId,
3379 LeftInfo,
3380 RightInfo,
3381 OutputIndices,
3382 }
3383 impl<'de> serde::Deserialize<'de> for GeneratedField {
3384 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3385 where
3386 D: serde::Deserializer<'de>,
3387 {
3388 struct GeneratedVisitor;
3389
3390 impl serde::de::Visitor<'_> for GeneratedVisitor {
3391 type Value = GeneratedField;
3392
3393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3394 write!(formatter, "expected one of: {:?}", &FIELDS)
3395 }
3396
3397 #[allow(unused_variables)]
3398 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3399 where
3400 E: serde::de::Error,
3401 {
3402 match value {
3403 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3404 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3405 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3406 "condition" => Ok(GeneratedField::Condition),
3407 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3408 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3409 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3410 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3411 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3412 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3413 }
3414 }
3415 }
3416 deserializer.deserialize_identifier(GeneratedVisitor)
3417 }
3418 }
3419 struct GeneratedVisitor;
3420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3421 type Value = DeltaIndexJoinNode;
3422
3423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3424 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3425 }
3426
3427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3428 where
3429 V: serde::de::MapAccess<'de>,
3430 {
3431 let mut join_type__ = None;
3432 let mut left_key__ = None;
3433 let mut right_key__ = None;
3434 let mut condition__ = None;
3435 let mut left_table_id__ = None;
3436 let mut right_table_id__ = None;
3437 let mut left_info__ = None;
3438 let mut right_info__ = None;
3439 let mut output_indices__ = None;
3440 while let Some(k) = map_.next_key()? {
3441 match k {
3442 GeneratedField::JoinType => {
3443 if join_type__.is_some() {
3444 return Err(serde::de::Error::duplicate_field("joinType"));
3445 }
3446 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3447 }
3448 GeneratedField::LeftKey => {
3449 if left_key__.is_some() {
3450 return Err(serde::de::Error::duplicate_field("leftKey"));
3451 }
3452 left_key__ =
3453 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3454 .into_iter().map(|x| x.0).collect())
3455 ;
3456 }
3457 GeneratedField::RightKey => {
3458 if right_key__.is_some() {
3459 return Err(serde::de::Error::duplicate_field("rightKey"));
3460 }
3461 right_key__ =
3462 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3463 .into_iter().map(|x| x.0).collect())
3464 ;
3465 }
3466 GeneratedField::Condition => {
3467 if condition__.is_some() {
3468 return Err(serde::de::Error::duplicate_field("condition"));
3469 }
3470 condition__ = map_.next_value()?;
3471 }
3472 GeneratedField::LeftTableId => {
3473 if left_table_id__.is_some() {
3474 return Err(serde::de::Error::duplicate_field("leftTableId"));
3475 }
3476 left_table_id__ =
3477 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3478 ;
3479 }
3480 GeneratedField::RightTableId => {
3481 if right_table_id__.is_some() {
3482 return Err(serde::de::Error::duplicate_field("rightTableId"));
3483 }
3484 right_table_id__ =
3485 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3486 ;
3487 }
3488 GeneratedField::LeftInfo => {
3489 if left_info__.is_some() {
3490 return Err(serde::de::Error::duplicate_field("leftInfo"));
3491 }
3492 left_info__ = map_.next_value()?;
3493 }
3494 GeneratedField::RightInfo => {
3495 if right_info__.is_some() {
3496 return Err(serde::de::Error::duplicate_field("rightInfo"));
3497 }
3498 right_info__ = map_.next_value()?;
3499 }
3500 GeneratedField::OutputIndices => {
3501 if output_indices__.is_some() {
3502 return Err(serde::de::Error::duplicate_field("outputIndices"));
3503 }
3504 output_indices__ =
3505 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3506 .into_iter().map(|x| x.0).collect())
3507 ;
3508 }
3509 }
3510 }
3511 Ok(DeltaIndexJoinNode {
3512 join_type: join_type__.unwrap_or_default(),
3513 left_key: left_key__.unwrap_or_default(),
3514 right_key: right_key__.unwrap_or_default(),
3515 condition: condition__,
3516 left_table_id: left_table_id__.unwrap_or_default(),
3517 right_table_id: right_table_id__.unwrap_or_default(),
3518 left_info: left_info__,
3519 right_info: right_info__,
3520 output_indices: output_indices__.unwrap_or_default(),
3521 })
3522 }
3523 }
3524 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3525 }
3526}
3527impl serde::Serialize for DispatchOutputMapping {
3528 #[allow(deprecated)]
3529 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3530 where
3531 S: serde::Serializer,
3532 {
3533 use serde::ser::SerializeStruct;
3534 let mut len = 0;
3535 if !self.indices.is_empty() {
3536 len += 1;
3537 }
3538 if !self.types.is_empty() {
3539 len += 1;
3540 }
3541 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3542 if !self.indices.is_empty() {
3543 struct_ser.serialize_field("indices", &self.indices)?;
3544 }
3545 if !self.types.is_empty() {
3546 struct_ser.serialize_field("types", &self.types)?;
3547 }
3548 struct_ser.end()
3549 }
3550}
3551impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3552 #[allow(deprecated)]
3553 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3554 where
3555 D: serde::Deserializer<'de>,
3556 {
3557 const FIELDS: &[&str] = &[
3558 "indices",
3559 "types",
3560 ];
3561
3562 #[allow(clippy::enum_variant_names)]
3563 enum GeneratedField {
3564 Indices,
3565 Types,
3566 }
3567 impl<'de> serde::Deserialize<'de> for GeneratedField {
3568 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3569 where
3570 D: serde::Deserializer<'de>,
3571 {
3572 struct GeneratedVisitor;
3573
3574 impl serde::de::Visitor<'_> for GeneratedVisitor {
3575 type Value = GeneratedField;
3576
3577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3578 write!(formatter, "expected one of: {:?}", &FIELDS)
3579 }
3580
3581 #[allow(unused_variables)]
3582 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3583 where
3584 E: serde::de::Error,
3585 {
3586 match value {
3587 "indices" => Ok(GeneratedField::Indices),
3588 "types" => Ok(GeneratedField::Types),
3589 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3590 }
3591 }
3592 }
3593 deserializer.deserialize_identifier(GeneratedVisitor)
3594 }
3595 }
3596 struct GeneratedVisitor;
3597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3598 type Value = DispatchOutputMapping;
3599
3600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3601 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3602 }
3603
3604 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3605 where
3606 V: serde::de::MapAccess<'de>,
3607 {
3608 let mut indices__ = None;
3609 let mut types__ = None;
3610 while let Some(k) = map_.next_key()? {
3611 match k {
3612 GeneratedField::Indices => {
3613 if indices__.is_some() {
3614 return Err(serde::de::Error::duplicate_field("indices"));
3615 }
3616 indices__ =
3617 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3618 .into_iter().map(|x| x.0).collect())
3619 ;
3620 }
3621 GeneratedField::Types => {
3622 if types__.is_some() {
3623 return Err(serde::de::Error::duplicate_field("types"));
3624 }
3625 types__ = Some(map_.next_value()?);
3626 }
3627 }
3628 }
3629 Ok(DispatchOutputMapping {
3630 indices: indices__.unwrap_or_default(),
3631 types: types__.unwrap_or_default(),
3632 })
3633 }
3634 }
3635 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3636 }
3637}
3638impl serde::Serialize for dispatch_output_mapping::TypePair {
3639 #[allow(deprecated)]
3640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3641 where
3642 S: serde::Serializer,
3643 {
3644 use serde::ser::SerializeStruct;
3645 let mut len = 0;
3646 if self.upstream.is_some() {
3647 len += 1;
3648 }
3649 if self.downstream.is_some() {
3650 len += 1;
3651 }
3652 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3653 if let Some(v) = self.upstream.as_ref() {
3654 struct_ser.serialize_field("upstream", v)?;
3655 }
3656 if let Some(v) = self.downstream.as_ref() {
3657 struct_ser.serialize_field("downstream", v)?;
3658 }
3659 struct_ser.end()
3660 }
3661}
3662impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3663 #[allow(deprecated)]
3664 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3665 where
3666 D: serde::Deserializer<'de>,
3667 {
3668 const FIELDS: &[&str] = &[
3669 "upstream",
3670 "downstream",
3671 ];
3672
3673 #[allow(clippy::enum_variant_names)]
3674 enum GeneratedField {
3675 Upstream,
3676 Downstream,
3677 }
3678 impl<'de> serde::Deserialize<'de> for GeneratedField {
3679 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3680 where
3681 D: serde::Deserializer<'de>,
3682 {
3683 struct GeneratedVisitor;
3684
3685 impl serde::de::Visitor<'_> for GeneratedVisitor {
3686 type Value = GeneratedField;
3687
3688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3689 write!(formatter, "expected one of: {:?}", &FIELDS)
3690 }
3691
3692 #[allow(unused_variables)]
3693 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3694 where
3695 E: serde::de::Error,
3696 {
3697 match value {
3698 "upstream" => Ok(GeneratedField::Upstream),
3699 "downstream" => Ok(GeneratedField::Downstream),
3700 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3701 }
3702 }
3703 }
3704 deserializer.deserialize_identifier(GeneratedVisitor)
3705 }
3706 }
3707 struct GeneratedVisitor;
3708 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3709 type Value = dispatch_output_mapping::TypePair;
3710
3711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3712 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3713 }
3714
3715 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3716 where
3717 V: serde::de::MapAccess<'de>,
3718 {
3719 let mut upstream__ = None;
3720 let mut downstream__ = None;
3721 while let Some(k) = map_.next_key()? {
3722 match k {
3723 GeneratedField::Upstream => {
3724 if upstream__.is_some() {
3725 return Err(serde::de::Error::duplicate_field("upstream"));
3726 }
3727 upstream__ = map_.next_value()?;
3728 }
3729 GeneratedField::Downstream => {
3730 if downstream__.is_some() {
3731 return Err(serde::de::Error::duplicate_field("downstream"));
3732 }
3733 downstream__ = map_.next_value()?;
3734 }
3735 }
3736 }
3737 Ok(dispatch_output_mapping::TypePair {
3738 upstream: upstream__,
3739 downstream: downstream__,
3740 })
3741 }
3742 }
3743 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3744 }
3745}
3746impl serde::Serialize for DispatchStrategy {
3747 #[allow(deprecated)]
3748 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3749 where
3750 S: serde::Serializer,
3751 {
3752 use serde::ser::SerializeStruct;
3753 let mut len = 0;
3754 if self.r#type != 0 {
3755 len += 1;
3756 }
3757 if !self.dist_key_indices.is_empty() {
3758 len += 1;
3759 }
3760 if self.output_mapping.is_some() {
3761 len += 1;
3762 }
3763 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3764 if self.r#type != 0 {
3765 let v = DispatcherType::try_from(self.r#type)
3766 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3767 struct_ser.serialize_field("type", &v)?;
3768 }
3769 if !self.dist_key_indices.is_empty() {
3770 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3771 }
3772 if let Some(v) = self.output_mapping.as_ref() {
3773 struct_ser.serialize_field("outputMapping", v)?;
3774 }
3775 struct_ser.end()
3776 }
3777}
3778impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3779 #[allow(deprecated)]
3780 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3781 where
3782 D: serde::Deserializer<'de>,
3783 {
3784 const FIELDS: &[&str] = &[
3785 "type",
3786 "dist_key_indices",
3787 "distKeyIndices",
3788 "output_mapping",
3789 "outputMapping",
3790 ];
3791
3792 #[allow(clippy::enum_variant_names)]
3793 enum GeneratedField {
3794 Type,
3795 DistKeyIndices,
3796 OutputMapping,
3797 }
3798 impl<'de> serde::Deserialize<'de> for GeneratedField {
3799 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3800 where
3801 D: serde::Deserializer<'de>,
3802 {
3803 struct GeneratedVisitor;
3804
3805 impl serde::de::Visitor<'_> for GeneratedVisitor {
3806 type Value = GeneratedField;
3807
3808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3809 write!(formatter, "expected one of: {:?}", &FIELDS)
3810 }
3811
3812 #[allow(unused_variables)]
3813 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3814 where
3815 E: serde::de::Error,
3816 {
3817 match value {
3818 "type" => Ok(GeneratedField::Type),
3819 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3820 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3821 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3822 }
3823 }
3824 }
3825 deserializer.deserialize_identifier(GeneratedVisitor)
3826 }
3827 }
3828 struct GeneratedVisitor;
3829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3830 type Value = DispatchStrategy;
3831
3832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3833 formatter.write_str("struct stream_plan.DispatchStrategy")
3834 }
3835
3836 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3837 where
3838 V: serde::de::MapAccess<'de>,
3839 {
3840 let mut r#type__ = None;
3841 let mut dist_key_indices__ = None;
3842 let mut output_mapping__ = None;
3843 while let Some(k) = map_.next_key()? {
3844 match k {
3845 GeneratedField::Type => {
3846 if r#type__.is_some() {
3847 return Err(serde::de::Error::duplicate_field("type"));
3848 }
3849 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3850 }
3851 GeneratedField::DistKeyIndices => {
3852 if dist_key_indices__.is_some() {
3853 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3854 }
3855 dist_key_indices__ =
3856 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3857 .into_iter().map(|x| x.0).collect())
3858 ;
3859 }
3860 GeneratedField::OutputMapping => {
3861 if output_mapping__.is_some() {
3862 return Err(serde::de::Error::duplicate_field("outputMapping"));
3863 }
3864 output_mapping__ = map_.next_value()?;
3865 }
3866 }
3867 }
3868 Ok(DispatchStrategy {
3869 r#type: r#type__.unwrap_or_default(),
3870 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3871 output_mapping: output_mapping__,
3872 })
3873 }
3874 }
3875 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3876 }
3877}
3878impl serde::Serialize for Dispatcher {
3879 #[allow(deprecated)]
3880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3881 where
3882 S: serde::Serializer,
3883 {
3884 use serde::ser::SerializeStruct;
3885 let mut len = 0;
3886 if self.r#type != 0 {
3887 len += 1;
3888 }
3889 if !self.dist_key_indices.is_empty() {
3890 len += 1;
3891 }
3892 if self.output_mapping.is_some() {
3893 len += 1;
3894 }
3895 if self.hash_mapping.is_some() {
3896 len += 1;
3897 }
3898 if self.dispatcher_id != 0 {
3899 len += 1;
3900 }
3901 if !self.downstream_actor_id.is_empty() {
3902 len += 1;
3903 }
3904 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3905 if self.r#type != 0 {
3906 let v = DispatcherType::try_from(self.r#type)
3907 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3908 struct_ser.serialize_field("type", &v)?;
3909 }
3910 if !self.dist_key_indices.is_empty() {
3911 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3912 }
3913 if let Some(v) = self.output_mapping.as_ref() {
3914 struct_ser.serialize_field("outputMapping", v)?;
3915 }
3916 if let Some(v) = self.hash_mapping.as_ref() {
3917 struct_ser.serialize_field("hashMapping", v)?;
3918 }
3919 if self.dispatcher_id != 0 {
3920 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
3921 }
3922 if !self.downstream_actor_id.is_empty() {
3923 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3924 }
3925 struct_ser.end()
3926 }
3927}
3928impl<'de> serde::Deserialize<'de> for Dispatcher {
3929 #[allow(deprecated)]
3930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3931 where
3932 D: serde::Deserializer<'de>,
3933 {
3934 const FIELDS: &[&str] = &[
3935 "type",
3936 "dist_key_indices",
3937 "distKeyIndices",
3938 "output_mapping",
3939 "outputMapping",
3940 "hash_mapping",
3941 "hashMapping",
3942 "dispatcher_id",
3943 "dispatcherId",
3944 "downstream_actor_id",
3945 "downstreamActorId",
3946 ];
3947
3948 #[allow(clippy::enum_variant_names)]
3949 enum GeneratedField {
3950 Type,
3951 DistKeyIndices,
3952 OutputMapping,
3953 HashMapping,
3954 DispatcherId,
3955 DownstreamActorId,
3956 }
3957 impl<'de> serde::Deserialize<'de> for GeneratedField {
3958 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3959 where
3960 D: serde::Deserializer<'de>,
3961 {
3962 struct GeneratedVisitor;
3963
3964 impl serde::de::Visitor<'_> for GeneratedVisitor {
3965 type Value = GeneratedField;
3966
3967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3968 write!(formatter, "expected one of: {:?}", &FIELDS)
3969 }
3970
3971 #[allow(unused_variables)]
3972 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3973 where
3974 E: serde::de::Error,
3975 {
3976 match value {
3977 "type" => Ok(GeneratedField::Type),
3978 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3979 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3980 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3981 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3982 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3983 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3984 }
3985 }
3986 }
3987 deserializer.deserialize_identifier(GeneratedVisitor)
3988 }
3989 }
3990 struct GeneratedVisitor;
3991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3992 type Value = Dispatcher;
3993
3994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3995 formatter.write_str("struct stream_plan.Dispatcher")
3996 }
3997
3998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3999 where
4000 V: serde::de::MapAccess<'de>,
4001 {
4002 let mut r#type__ = None;
4003 let mut dist_key_indices__ = None;
4004 let mut output_mapping__ = None;
4005 let mut hash_mapping__ = None;
4006 let mut dispatcher_id__ = None;
4007 let mut downstream_actor_id__ = None;
4008 while let Some(k) = map_.next_key()? {
4009 match k {
4010 GeneratedField::Type => {
4011 if r#type__.is_some() {
4012 return Err(serde::de::Error::duplicate_field("type"));
4013 }
4014 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
4015 }
4016 GeneratedField::DistKeyIndices => {
4017 if dist_key_indices__.is_some() {
4018 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
4019 }
4020 dist_key_indices__ =
4021 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4022 .into_iter().map(|x| x.0).collect())
4023 ;
4024 }
4025 GeneratedField::OutputMapping => {
4026 if output_mapping__.is_some() {
4027 return Err(serde::de::Error::duplicate_field("outputMapping"));
4028 }
4029 output_mapping__ = map_.next_value()?;
4030 }
4031 GeneratedField::HashMapping => {
4032 if hash_mapping__.is_some() {
4033 return Err(serde::de::Error::duplicate_field("hashMapping"));
4034 }
4035 hash_mapping__ = map_.next_value()?;
4036 }
4037 GeneratedField::DispatcherId => {
4038 if dispatcher_id__.is_some() {
4039 return Err(serde::de::Error::duplicate_field("dispatcherId"));
4040 }
4041 dispatcher_id__ =
4042 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4043 ;
4044 }
4045 GeneratedField::DownstreamActorId => {
4046 if downstream_actor_id__.is_some() {
4047 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
4048 }
4049 downstream_actor_id__ =
4050 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4051 .into_iter().map(|x| x.0).collect())
4052 ;
4053 }
4054 }
4055 }
4056 Ok(Dispatcher {
4057 r#type: r#type__.unwrap_or_default(),
4058 dist_key_indices: dist_key_indices__.unwrap_or_default(),
4059 output_mapping: output_mapping__,
4060 hash_mapping: hash_mapping__,
4061 dispatcher_id: dispatcher_id__.unwrap_or_default(),
4062 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
4063 })
4064 }
4065 }
4066 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
4067 }
4068}
4069impl serde::Serialize for DispatcherType {
4070 #[allow(deprecated)]
4071 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4072 where
4073 S: serde::Serializer,
4074 {
4075 let variant = match self {
4076 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
4077 Self::Hash => "DISPATCHER_TYPE_HASH",
4078 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
4079 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
4080 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
4081 };
4082 serializer.serialize_str(variant)
4083 }
4084}
4085impl<'de> serde::Deserialize<'de> for DispatcherType {
4086 #[allow(deprecated)]
4087 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4088 where
4089 D: serde::Deserializer<'de>,
4090 {
4091 const FIELDS: &[&str] = &[
4092 "DISPATCHER_TYPE_UNSPECIFIED",
4093 "DISPATCHER_TYPE_HASH",
4094 "DISPATCHER_TYPE_BROADCAST",
4095 "DISPATCHER_TYPE_SIMPLE",
4096 "DISPATCHER_TYPE_NO_SHUFFLE",
4097 ];
4098
4099 struct GeneratedVisitor;
4100
4101 impl serde::de::Visitor<'_> for GeneratedVisitor {
4102 type Value = DispatcherType;
4103
4104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4105 write!(formatter, "expected one of: {:?}", &FIELDS)
4106 }
4107
4108 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4109 where
4110 E: serde::de::Error,
4111 {
4112 i32::try_from(v)
4113 .ok()
4114 .and_then(|x| x.try_into().ok())
4115 .ok_or_else(|| {
4116 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4117 })
4118 }
4119
4120 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4121 where
4122 E: serde::de::Error,
4123 {
4124 i32::try_from(v)
4125 .ok()
4126 .and_then(|x| x.try_into().ok())
4127 .ok_or_else(|| {
4128 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4129 })
4130 }
4131
4132 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4133 where
4134 E: serde::de::Error,
4135 {
4136 match value {
4137 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
4138 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
4139 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
4140 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
4141 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
4142 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4143 }
4144 }
4145 }
4146 deserializer.deserialize_any(GeneratedVisitor)
4147 }
4148}
4149impl serde::Serialize for Dispatchers {
4150 #[allow(deprecated)]
4151 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4152 where
4153 S: serde::Serializer,
4154 {
4155 use serde::ser::SerializeStruct;
4156 let mut len = 0;
4157 if !self.dispatchers.is_empty() {
4158 len += 1;
4159 }
4160 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
4161 if !self.dispatchers.is_empty() {
4162 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
4163 }
4164 struct_ser.end()
4165 }
4166}
4167impl<'de> serde::Deserialize<'de> for Dispatchers {
4168 #[allow(deprecated)]
4169 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4170 where
4171 D: serde::Deserializer<'de>,
4172 {
4173 const FIELDS: &[&str] = &[
4174 "dispatchers",
4175 ];
4176
4177 #[allow(clippy::enum_variant_names)]
4178 enum GeneratedField {
4179 Dispatchers,
4180 }
4181 impl<'de> serde::Deserialize<'de> for GeneratedField {
4182 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4183 where
4184 D: serde::Deserializer<'de>,
4185 {
4186 struct GeneratedVisitor;
4187
4188 impl serde::de::Visitor<'_> for GeneratedVisitor {
4189 type Value = GeneratedField;
4190
4191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4192 write!(formatter, "expected one of: {:?}", &FIELDS)
4193 }
4194
4195 #[allow(unused_variables)]
4196 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4197 where
4198 E: serde::de::Error,
4199 {
4200 match value {
4201 "dispatchers" => Ok(GeneratedField::Dispatchers),
4202 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4203 }
4204 }
4205 }
4206 deserializer.deserialize_identifier(GeneratedVisitor)
4207 }
4208 }
4209 struct GeneratedVisitor;
4210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4211 type Value = Dispatchers;
4212
4213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4214 formatter.write_str("struct stream_plan.Dispatchers")
4215 }
4216
4217 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
4218 where
4219 V: serde::de::MapAccess<'de>,
4220 {
4221 let mut dispatchers__ = None;
4222 while let Some(k) = map_.next_key()? {
4223 match k {
4224 GeneratedField::Dispatchers => {
4225 if dispatchers__.is_some() {
4226 return Err(serde::de::Error::duplicate_field("dispatchers"));
4227 }
4228 dispatchers__ = Some(map_.next_value()?);
4229 }
4230 }
4231 }
4232 Ok(Dispatchers {
4233 dispatchers: dispatchers__.unwrap_or_default(),
4234 })
4235 }
4236 }
4237 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
4238 }
4239}
4240impl serde::Serialize for DmlNode {
4241 #[allow(deprecated)]
4242 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4243 where
4244 S: serde::Serializer,
4245 {
4246 use serde::ser::SerializeStruct;
4247 let mut len = 0;
4248 if self.table_id != 0 {
4249 len += 1;
4250 }
4251 if self.table_version_id != 0 {
4252 len += 1;
4253 }
4254 if !self.column_descs.is_empty() {
4255 len += 1;
4256 }
4257 if self.rate_limit.is_some() {
4258 len += 1;
4259 }
4260 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
4261 if self.table_id != 0 {
4262 struct_ser.serialize_field("tableId", &self.table_id)?;
4263 }
4264 if self.table_version_id != 0 {
4265 #[allow(clippy::needless_borrow)]
4266 #[allow(clippy::needless_borrows_for_generic_args)]
4267 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
4268 }
4269 if !self.column_descs.is_empty() {
4270 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
4271 }
4272 if let Some(v) = self.rate_limit.as_ref() {
4273 struct_ser.serialize_field("rateLimit", v)?;
4274 }
4275 struct_ser.end()
4276 }
4277}
4278impl<'de> serde::Deserialize<'de> for DmlNode {
4279 #[allow(deprecated)]
4280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4281 where
4282 D: serde::Deserializer<'de>,
4283 {
4284 const FIELDS: &[&str] = &[
4285 "table_id",
4286 "tableId",
4287 "table_version_id",
4288 "tableVersionId",
4289 "column_descs",
4290 "columnDescs",
4291 "rate_limit",
4292 "rateLimit",
4293 ];
4294
4295 #[allow(clippy::enum_variant_names)]
4296 enum GeneratedField {
4297 TableId,
4298 TableVersionId,
4299 ColumnDescs,
4300 RateLimit,
4301 }
4302 impl<'de> serde::Deserialize<'de> for GeneratedField {
4303 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4304 where
4305 D: serde::Deserializer<'de>,
4306 {
4307 struct GeneratedVisitor;
4308
4309 impl serde::de::Visitor<'_> for GeneratedVisitor {
4310 type Value = GeneratedField;
4311
4312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4313 write!(formatter, "expected one of: {:?}", &FIELDS)
4314 }
4315
4316 #[allow(unused_variables)]
4317 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4318 where
4319 E: serde::de::Error,
4320 {
4321 match value {
4322 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4323 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4324 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4325 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4326 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4327 }
4328 }
4329 }
4330 deserializer.deserialize_identifier(GeneratedVisitor)
4331 }
4332 }
4333 struct GeneratedVisitor;
4334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4335 type Value = DmlNode;
4336
4337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4338 formatter.write_str("struct stream_plan.DmlNode")
4339 }
4340
4341 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4342 where
4343 V: serde::de::MapAccess<'de>,
4344 {
4345 let mut table_id__ = None;
4346 let mut table_version_id__ = None;
4347 let mut column_descs__ = None;
4348 let mut rate_limit__ = None;
4349 while let Some(k) = map_.next_key()? {
4350 match k {
4351 GeneratedField::TableId => {
4352 if table_id__.is_some() {
4353 return Err(serde::de::Error::duplicate_field("tableId"));
4354 }
4355 table_id__ =
4356 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4357 ;
4358 }
4359 GeneratedField::TableVersionId => {
4360 if table_version_id__.is_some() {
4361 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4362 }
4363 table_version_id__ =
4364 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4365 ;
4366 }
4367 GeneratedField::ColumnDescs => {
4368 if column_descs__.is_some() {
4369 return Err(serde::de::Error::duplicate_field("columnDescs"));
4370 }
4371 column_descs__ = Some(map_.next_value()?);
4372 }
4373 GeneratedField::RateLimit => {
4374 if rate_limit__.is_some() {
4375 return Err(serde::de::Error::duplicate_field("rateLimit"));
4376 }
4377 rate_limit__ =
4378 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4379 ;
4380 }
4381 }
4382 }
4383 Ok(DmlNode {
4384 table_id: table_id__.unwrap_or_default(),
4385 table_version_id: table_version_id__.unwrap_or_default(),
4386 column_descs: column_descs__.unwrap_or_default(),
4387 rate_limit: rate_limit__,
4388 })
4389 }
4390 }
4391 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4392 }
4393}
4394impl serde::Serialize for DropSubscriptionsMutation {
4395 #[allow(deprecated)]
4396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4397 where
4398 S: serde::Serializer,
4399 {
4400 use serde::ser::SerializeStruct;
4401 let mut len = 0;
4402 if !self.info.is_empty() {
4403 len += 1;
4404 }
4405 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4406 if !self.info.is_empty() {
4407 struct_ser.serialize_field("info", &self.info)?;
4408 }
4409 struct_ser.end()
4410 }
4411}
4412impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4413 #[allow(deprecated)]
4414 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4415 where
4416 D: serde::Deserializer<'de>,
4417 {
4418 const FIELDS: &[&str] = &[
4419 "info",
4420 ];
4421
4422 #[allow(clippy::enum_variant_names)]
4423 enum GeneratedField {
4424 Info,
4425 }
4426 impl<'de> serde::Deserialize<'de> for GeneratedField {
4427 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4428 where
4429 D: serde::Deserializer<'de>,
4430 {
4431 struct GeneratedVisitor;
4432
4433 impl serde::de::Visitor<'_> for GeneratedVisitor {
4434 type Value = GeneratedField;
4435
4436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4437 write!(formatter, "expected one of: {:?}", &FIELDS)
4438 }
4439
4440 #[allow(unused_variables)]
4441 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4442 where
4443 E: serde::de::Error,
4444 {
4445 match value {
4446 "info" => Ok(GeneratedField::Info),
4447 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4448 }
4449 }
4450 }
4451 deserializer.deserialize_identifier(GeneratedVisitor)
4452 }
4453 }
4454 struct GeneratedVisitor;
4455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4456 type Value = DropSubscriptionsMutation;
4457
4458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4459 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4460 }
4461
4462 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4463 where
4464 V: serde::de::MapAccess<'de>,
4465 {
4466 let mut info__ = None;
4467 while let Some(k) = map_.next_key()? {
4468 match k {
4469 GeneratedField::Info => {
4470 if info__.is_some() {
4471 return Err(serde::de::Error::duplicate_field("info"));
4472 }
4473 info__ = Some(map_.next_value()?);
4474 }
4475 }
4476 }
4477 Ok(DropSubscriptionsMutation {
4478 info: info__.unwrap_or_default(),
4479 })
4480 }
4481 }
4482 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4483 }
4484}
4485impl serde::Serialize for DynamicFilterNode {
4486 #[allow(deprecated)]
4487 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4488 where
4489 S: serde::Serializer,
4490 {
4491 use serde::ser::SerializeStruct;
4492 let mut len = 0;
4493 if self.left_key != 0 {
4494 len += 1;
4495 }
4496 if self.condition.is_some() {
4497 len += 1;
4498 }
4499 if self.left_table.is_some() {
4500 len += 1;
4501 }
4502 if self.right_table.is_some() {
4503 len += 1;
4504 }
4505 if self.condition_always_relax {
4506 len += 1;
4507 }
4508 if self.cleaned_by_watermark {
4509 len += 1;
4510 }
4511 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4512 if self.left_key != 0 {
4513 struct_ser.serialize_field("leftKey", &self.left_key)?;
4514 }
4515 if let Some(v) = self.condition.as_ref() {
4516 struct_ser.serialize_field("condition", v)?;
4517 }
4518 if let Some(v) = self.left_table.as_ref() {
4519 struct_ser.serialize_field("leftTable", v)?;
4520 }
4521 if let Some(v) = self.right_table.as_ref() {
4522 struct_ser.serialize_field("rightTable", v)?;
4523 }
4524 if self.condition_always_relax {
4525 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4526 }
4527 if self.cleaned_by_watermark {
4528 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4529 }
4530 struct_ser.end()
4531 }
4532}
4533impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4534 #[allow(deprecated)]
4535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4536 where
4537 D: serde::Deserializer<'de>,
4538 {
4539 const FIELDS: &[&str] = &[
4540 "left_key",
4541 "leftKey",
4542 "condition",
4543 "left_table",
4544 "leftTable",
4545 "right_table",
4546 "rightTable",
4547 "condition_always_relax",
4548 "conditionAlwaysRelax",
4549 "cleaned_by_watermark",
4550 "cleanedByWatermark",
4551 ];
4552
4553 #[allow(clippy::enum_variant_names)]
4554 enum GeneratedField {
4555 LeftKey,
4556 Condition,
4557 LeftTable,
4558 RightTable,
4559 ConditionAlwaysRelax,
4560 CleanedByWatermark,
4561 }
4562 impl<'de> serde::Deserialize<'de> for GeneratedField {
4563 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4564 where
4565 D: serde::Deserializer<'de>,
4566 {
4567 struct GeneratedVisitor;
4568
4569 impl serde::de::Visitor<'_> for GeneratedVisitor {
4570 type Value = GeneratedField;
4571
4572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4573 write!(formatter, "expected one of: {:?}", &FIELDS)
4574 }
4575
4576 #[allow(unused_variables)]
4577 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4578 where
4579 E: serde::de::Error,
4580 {
4581 match value {
4582 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4583 "condition" => Ok(GeneratedField::Condition),
4584 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4585 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4586 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4587 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4588 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4589 }
4590 }
4591 }
4592 deserializer.deserialize_identifier(GeneratedVisitor)
4593 }
4594 }
4595 struct GeneratedVisitor;
4596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4597 type Value = DynamicFilterNode;
4598
4599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4600 formatter.write_str("struct stream_plan.DynamicFilterNode")
4601 }
4602
4603 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4604 where
4605 V: serde::de::MapAccess<'de>,
4606 {
4607 let mut left_key__ = None;
4608 let mut condition__ = None;
4609 let mut left_table__ = None;
4610 let mut right_table__ = None;
4611 let mut condition_always_relax__ = None;
4612 let mut cleaned_by_watermark__ = None;
4613 while let Some(k) = map_.next_key()? {
4614 match k {
4615 GeneratedField::LeftKey => {
4616 if left_key__.is_some() {
4617 return Err(serde::de::Error::duplicate_field("leftKey"));
4618 }
4619 left_key__ =
4620 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4621 ;
4622 }
4623 GeneratedField::Condition => {
4624 if condition__.is_some() {
4625 return Err(serde::de::Error::duplicate_field("condition"));
4626 }
4627 condition__ = map_.next_value()?;
4628 }
4629 GeneratedField::LeftTable => {
4630 if left_table__.is_some() {
4631 return Err(serde::de::Error::duplicate_field("leftTable"));
4632 }
4633 left_table__ = map_.next_value()?;
4634 }
4635 GeneratedField::RightTable => {
4636 if right_table__.is_some() {
4637 return Err(serde::de::Error::duplicate_field("rightTable"));
4638 }
4639 right_table__ = map_.next_value()?;
4640 }
4641 GeneratedField::ConditionAlwaysRelax => {
4642 if condition_always_relax__.is_some() {
4643 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4644 }
4645 condition_always_relax__ = Some(map_.next_value()?);
4646 }
4647 GeneratedField::CleanedByWatermark => {
4648 if cleaned_by_watermark__.is_some() {
4649 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4650 }
4651 cleaned_by_watermark__ = Some(map_.next_value()?);
4652 }
4653 }
4654 }
4655 Ok(DynamicFilterNode {
4656 left_key: left_key__.unwrap_or_default(),
4657 condition: condition__,
4658 left_table: left_table__,
4659 right_table: right_table__,
4660 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4661 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4662 })
4663 }
4664 }
4665 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4666 }
4667}
4668impl serde::Serialize for EowcGapFillNode {
4669 #[allow(deprecated)]
4670 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4671 where
4672 S: serde::Serializer,
4673 {
4674 use serde::ser::SerializeStruct;
4675 let mut len = 0;
4676 if self.time_column_index != 0 {
4677 len += 1;
4678 }
4679 if self.interval.is_some() {
4680 len += 1;
4681 }
4682 if !self.fill_columns.is_empty() {
4683 len += 1;
4684 }
4685 if !self.fill_strategies.is_empty() {
4686 len += 1;
4687 }
4688 if self.prev_row_table.is_some() {
4689 len += 1;
4690 }
4691 if !self.partition_by_indices.is_empty() {
4692 len += 1;
4693 }
4694 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4695 if self.time_column_index != 0 {
4696 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4697 }
4698 if let Some(v) = self.interval.as_ref() {
4699 struct_ser.serialize_field("interval", v)?;
4700 }
4701 if !self.fill_columns.is_empty() {
4702 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4703 }
4704 if !self.fill_strategies.is_empty() {
4705 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4706 }
4707 if let Some(v) = self.prev_row_table.as_ref() {
4708 struct_ser.serialize_field("prevRowTable", v)?;
4709 }
4710 if !self.partition_by_indices.is_empty() {
4711 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
4712 }
4713 struct_ser.end()
4714 }
4715}
4716impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4717 #[allow(deprecated)]
4718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4719 where
4720 D: serde::Deserializer<'de>,
4721 {
4722 const FIELDS: &[&str] = &[
4723 "time_column_index",
4724 "timeColumnIndex",
4725 "interval",
4726 "fill_columns",
4727 "fillColumns",
4728 "fill_strategies",
4729 "fillStrategies",
4730 "prev_row_table",
4731 "prevRowTable",
4732 "partition_by_indices",
4733 "partitionByIndices",
4734 ];
4735
4736 #[allow(clippy::enum_variant_names)]
4737 enum GeneratedField {
4738 TimeColumnIndex,
4739 Interval,
4740 FillColumns,
4741 FillStrategies,
4742 PrevRowTable,
4743 PartitionByIndices,
4744 }
4745 impl<'de> serde::Deserialize<'de> for GeneratedField {
4746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4747 where
4748 D: serde::Deserializer<'de>,
4749 {
4750 struct GeneratedVisitor;
4751
4752 impl serde::de::Visitor<'_> for GeneratedVisitor {
4753 type Value = GeneratedField;
4754
4755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4756 write!(formatter, "expected one of: {:?}", &FIELDS)
4757 }
4758
4759 #[allow(unused_variables)]
4760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4761 where
4762 E: serde::de::Error,
4763 {
4764 match value {
4765 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4766 "interval" => Ok(GeneratedField::Interval),
4767 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4768 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4769 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4770 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
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 = EowcGapFillNode;
4781
4782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4783 formatter.write_str("struct stream_plan.EowcGapFillNode")
4784 }
4785
4786 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4787 where
4788 V: serde::de::MapAccess<'de>,
4789 {
4790 let mut time_column_index__ = None;
4791 let mut interval__ = None;
4792 let mut fill_columns__ = None;
4793 let mut fill_strategies__ = None;
4794 let mut prev_row_table__ = None;
4795 let mut partition_by_indices__ = None;
4796 while let Some(k) = map_.next_key()? {
4797 match k {
4798 GeneratedField::TimeColumnIndex => {
4799 if time_column_index__.is_some() {
4800 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4801 }
4802 time_column_index__ =
4803 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4804 ;
4805 }
4806 GeneratedField::Interval => {
4807 if interval__.is_some() {
4808 return Err(serde::de::Error::duplicate_field("interval"));
4809 }
4810 interval__ = map_.next_value()?;
4811 }
4812 GeneratedField::FillColumns => {
4813 if fill_columns__.is_some() {
4814 return Err(serde::de::Error::duplicate_field("fillColumns"));
4815 }
4816 fill_columns__ =
4817 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4818 .into_iter().map(|x| x.0).collect())
4819 ;
4820 }
4821 GeneratedField::FillStrategies => {
4822 if fill_strategies__.is_some() {
4823 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4824 }
4825 fill_strategies__ = Some(map_.next_value()?);
4826 }
4827 GeneratedField::PrevRowTable => {
4828 if prev_row_table__.is_some() {
4829 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4830 }
4831 prev_row_table__ = map_.next_value()?;
4832 }
4833 GeneratedField::PartitionByIndices => {
4834 if partition_by_indices__.is_some() {
4835 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
4836 }
4837 partition_by_indices__ =
4838 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4839 .into_iter().map(|x| x.0).collect())
4840 ;
4841 }
4842 }
4843 }
4844 Ok(EowcGapFillNode {
4845 time_column_index: time_column_index__.unwrap_or_default(),
4846 interval: interval__,
4847 fill_columns: fill_columns__.unwrap_or_default(),
4848 fill_strategies: fill_strategies__.unwrap_or_default(),
4849 prev_row_table: prev_row_table__,
4850 partition_by_indices: partition_by_indices__.unwrap_or_default(),
4851 })
4852 }
4853 }
4854 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4855 }
4856}
4857impl serde::Serialize for EowcOverWindowNode {
4858 #[allow(deprecated)]
4859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4860 where
4861 S: serde::Serializer,
4862 {
4863 use serde::ser::SerializeStruct;
4864 let mut len = 0;
4865 if !self.calls.is_empty() {
4866 len += 1;
4867 }
4868 if !self.partition_by.is_empty() {
4869 len += 1;
4870 }
4871 if !self.order_by.is_empty() {
4872 len += 1;
4873 }
4874 if self.state_table.is_some() {
4875 len += 1;
4876 }
4877 if self.intermediate_state_table.is_some() {
4878 len += 1;
4879 }
4880 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4881 if !self.calls.is_empty() {
4882 struct_ser.serialize_field("calls", &self.calls)?;
4883 }
4884 if !self.partition_by.is_empty() {
4885 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4886 }
4887 if !self.order_by.is_empty() {
4888 struct_ser.serialize_field("orderBy", &self.order_by)?;
4889 }
4890 if let Some(v) = self.state_table.as_ref() {
4891 struct_ser.serialize_field("stateTable", v)?;
4892 }
4893 if let Some(v) = self.intermediate_state_table.as_ref() {
4894 struct_ser.serialize_field("intermediateStateTable", v)?;
4895 }
4896 struct_ser.end()
4897 }
4898}
4899impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4900 #[allow(deprecated)]
4901 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4902 where
4903 D: serde::Deserializer<'de>,
4904 {
4905 const FIELDS: &[&str] = &[
4906 "calls",
4907 "partition_by",
4908 "partitionBy",
4909 "order_by",
4910 "orderBy",
4911 "state_table",
4912 "stateTable",
4913 "intermediate_state_table",
4914 "intermediateStateTable",
4915 ];
4916
4917 #[allow(clippy::enum_variant_names)]
4918 enum GeneratedField {
4919 Calls,
4920 PartitionBy,
4921 OrderBy,
4922 StateTable,
4923 IntermediateStateTable,
4924 }
4925 impl<'de> serde::Deserialize<'de> for GeneratedField {
4926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4927 where
4928 D: serde::Deserializer<'de>,
4929 {
4930 struct GeneratedVisitor;
4931
4932 impl serde::de::Visitor<'_> for GeneratedVisitor {
4933 type Value = GeneratedField;
4934
4935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4936 write!(formatter, "expected one of: {:?}", &FIELDS)
4937 }
4938
4939 #[allow(unused_variables)]
4940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4941 where
4942 E: serde::de::Error,
4943 {
4944 match value {
4945 "calls" => Ok(GeneratedField::Calls),
4946 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4947 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4948 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4949 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
4950 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4951 }
4952 }
4953 }
4954 deserializer.deserialize_identifier(GeneratedVisitor)
4955 }
4956 }
4957 struct GeneratedVisitor;
4958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4959 type Value = EowcOverWindowNode;
4960
4961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4962 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4963 }
4964
4965 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4966 where
4967 V: serde::de::MapAccess<'de>,
4968 {
4969 let mut calls__ = None;
4970 let mut partition_by__ = None;
4971 let mut order_by__ = None;
4972 let mut state_table__ = None;
4973 let mut intermediate_state_table__ = None;
4974 while let Some(k) = map_.next_key()? {
4975 match k {
4976 GeneratedField::Calls => {
4977 if calls__.is_some() {
4978 return Err(serde::de::Error::duplicate_field("calls"));
4979 }
4980 calls__ = Some(map_.next_value()?);
4981 }
4982 GeneratedField::PartitionBy => {
4983 if partition_by__.is_some() {
4984 return Err(serde::de::Error::duplicate_field("partitionBy"));
4985 }
4986 partition_by__ =
4987 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4988 .into_iter().map(|x| x.0).collect())
4989 ;
4990 }
4991 GeneratedField::OrderBy => {
4992 if order_by__.is_some() {
4993 return Err(serde::de::Error::duplicate_field("orderBy"));
4994 }
4995 order_by__ = Some(map_.next_value()?);
4996 }
4997 GeneratedField::StateTable => {
4998 if state_table__.is_some() {
4999 return Err(serde::de::Error::duplicate_field("stateTable"));
5000 }
5001 state_table__ = map_.next_value()?;
5002 }
5003 GeneratedField::IntermediateStateTable => {
5004 if intermediate_state_table__.is_some() {
5005 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5006 }
5007 intermediate_state_table__ = map_.next_value()?;
5008 }
5009 }
5010 }
5011 Ok(EowcOverWindowNode {
5012 calls: calls__.unwrap_or_default(),
5013 partition_by: partition_by__.unwrap_or_default(),
5014 order_by: order_by__.unwrap_or_default(),
5015 state_table: state_table__,
5016 intermediate_state_table: intermediate_state_table__,
5017 })
5018 }
5019 }
5020 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
5021 }
5022}
5023impl serde::Serialize for ExchangeNode {
5024 #[allow(deprecated)]
5025 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5026 where
5027 S: serde::Serializer,
5028 {
5029 use serde::ser::SerializeStruct;
5030 let mut len = 0;
5031 if self.strategy.is_some() {
5032 len += 1;
5033 }
5034 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
5035 if let Some(v) = self.strategy.as_ref() {
5036 struct_ser.serialize_field("strategy", v)?;
5037 }
5038 struct_ser.end()
5039 }
5040}
5041impl<'de> serde::Deserialize<'de> for ExchangeNode {
5042 #[allow(deprecated)]
5043 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5044 where
5045 D: serde::Deserializer<'de>,
5046 {
5047 const FIELDS: &[&str] = &[
5048 "strategy",
5049 ];
5050
5051 #[allow(clippy::enum_variant_names)]
5052 enum GeneratedField {
5053 Strategy,
5054 }
5055 impl<'de> serde::Deserialize<'de> for GeneratedField {
5056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5057 where
5058 D: serde::Deserializer<'de>,
5059 {
5060 struct GeneratedVisitor;
5061
5062 impl serde::de::Visitor<'_> for GeneratedVisitor {
5063 type Value = GeneratedField;
5064
5065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5066 write!(formatter, "expected one of: {:?}", &FIELDS)
5067 }
5068
5069 #[allow(unused_variables)]
5070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5071 where
5072 E: serde::de::Error,
5073 {
5074 match value {
5075 "strategy" => Ok(GeneratedField::Strategy),
5076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5077 }
5078 }
5079 }
5080 deserializer.deserialize_identifier(GeneratedVisitor)
5081 }
5082 }
5083 struct GeneratedVisitor;
5084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5085 type Value = ExchangeNode;
5086
5087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5088 formatter.write_str("struct stream_plan.ExchangeNode")
5089 }
5090
5091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
5092 where
5093 V: serde::de::MapAccess<'de>,
5094 {
5095 let mut strategy__ = None;
5096 while let Some(k) = map_.next_key()? {
5097 match k {
5098 GeneratedField::Strategy => {
5099 if strategy__.is_some() {
5100 return Err(serde::de::Error::duplicate_field("strategy"));
5101 }
5102 strategy__ = map_.next_value()?;
5103 }
5104 }
5105 }
5106 Ok(ExchangeNode {
5107 strategy: strategy__,
5108 })
5109 }
5110 }
5111 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
5112 }
5113}
5114impl serde::Serialize for ExpandNode {
5115 #[allow(deprecated)]
5116 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5117 where
5118 S: serde::Serializer,
5119 {
5120 use serde::ser::SerializeStruct;
5121 let mut len = 0;
5122 if !self.column_subsets.is_empty() {
5123 len += 1;
5124 }
5125 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
5126 if !self.column_subsets.is_empty() {
5127 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
5128 }
5129 struct_ser.end()
5130 }
5131}
5132impl<'de> serde::Deserialize<'de> for ExpandNode {
5133 #[allow(deprecated)]
5134 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5135 where
5136 D: serde::Deserializer<'de>,
5137 {
5138 const FIELDS: &[&str] = &[
5139 "column_subsets",
5140 "columnSubsets",
5141 ];
5142
5143 #[allow(clippy::enum_variant_names)]
5144 enum GeneratedField {
5145 ColumnSubsets,
5146 }
5147 impl<'de> serde::Deserialize<'de> for GeneratedField {
5148 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5149 where
5150 D: serde::Deserializer<'de>,
5151 {
5152 struct GeneratedVisitor;
5153
5154 impl serde::de::Visitor<'_> for GeneratedVisitor {
5155 type Value = GeneratedField;
5156
5157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5158 write!(formatter, "expected one of: {:?}", &FIELDS)
5159 }
5160
5161 #[allow(unused_variables)]
5162 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5163 where
5164 E: serde::de::Error,
5165 {
5166 match value {
5167 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
5168 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5169 }
5170 }
5171 }
5172 deserializer.deserialize_identifier(GeneratedVisitor)
5173 }
5174 }
5175 struct GeneratedVisitor;
5176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5177 type Value = ExpandNode;
5178
5179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5180 formatter.write_str("struct stream_plan.ExpandNode")
5181 }
5182
5183 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
5184 where
5185 V: serde::de::MapAccess<'de>,
5186 {
5187 let mut column_subsets__ = None;
5188 while let Some(k) = map_.next_key()? {
5189 match k {
5190 GeneratedField::ColumnSubsets => {
5191 if column_subsets__.is_some() {
5192 return Err(serde::de::Error::duplicate_field("columnSubsets"));
5193 }
5194 column_subsets__ = Some(map_.next_value()?);
5195 }
5196 }
5197 }
5198 Ok(ExpandNode {
5199 column_subsets: column_subsets__.unwrap_or_default(),
5200 })
5201 }
5202 }
5203 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
5204 }
5205}
5206impl serde::Serialize for expand_node::Subset {
5207 #[allow(deprecated)]
5208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5209 where
5210 S: serde::Serializer,
5211 {
5212 use serde::ser::SerializeStruct;
5213 let mut len = 0;
5214 if !self.column_indices.is_empty() {
5215 len += 1;
5216 }
5217 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
5218 if !self.column_indices.is_empty() {
5219 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
5220 }
5221 struct_ser.end()
5222 }
5223}
5224impl<'de> serde::Deserialize<'de> for expand_node::Subset {
5225 #[allow(deprecated)]
5226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5227 where
5228 D: serde::Deserializer<'de>,
5229 {
5230 const FIELDS: &[&str] = &[
5231 "column_indices",
5232 "columnIndices",
5233 ];
5234
5235 #[allow(clippy::enum_variant_names)]
5236 enum GeneratedField {
5237 ColumnIndices,
5238 }
5239 impl<'de> serde::Deserialize<'de> for GeneratedField {
5240 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5241 where
5242 D: serde::Deserializer<'de>,
5243 {
5244 struct GeneratedVisitor;
5245
5246 impl serde::de::Visitor<'_> for GeneratedVisitor {
5247 type Value = GeneratedField;
5248
5249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5250 write!(formatter, "expected one of: {:?}", &FIELDS)
5251 }
5252
5253 #[allow(unused_variables)]
5254 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5255 where
5256 E: serde::de::Error,
5257 {
5258 match value {
5259 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
5260 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5261 }
5262 }
5263 }
5264 deserializer.deserialize_identifier(GeneratedVisitor)
5265 }
5266 }
5267 struct GeneratedVisitor;
5268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5269 type Value = expand_node::Subset;
5270
5271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5272 formatter.write_str("struct stream_plan.ExpandNode.Subset")
5273 }
5274
5275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
5276 where
5277 V: serde::de::MapAccess<'de>,
5278 {
5279 let mut column_indices__ = None;
5280 while let Some(k) = map_.next_key()? {
5281 match k {
5282 GeneratedField::ColumnIndices => {
5283 if column_indices__.is_some() {
5284 return Err(serde::de::Error::duplicate_field("columnIndices"));
5285 }
5286 column_indices__ =
5287 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5288 .into_iter().map(|x| x.0).collect())
5289 ;
5290 }
5291 }
5292 }
5293 Ok(expand_node::Subset {
5294 column_indices: column_indices__.unwrap_or_default(),
5295 })
5296 }
5297 }
5298 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
5299 }
5300}
5301impl serde::Serialize for FilterNode {
5302 #[allow(deprecated)]
5303 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5304 where
5305 S: serde::Serializer,
5306 {
5307 use serde::ser::SerializeStruct;
5308 let mut len = 0;
5309 if self.search_condition.is_some() {
5310 len += 1;
5311 }
5312 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
5313 if let Some(v) = self.search_condition.as_ref() {
5314 struct_ser.serialize_field("searchCondition", v)?;
5315 }
5316 struct_ser.end()
5317 }
5318}
5319impl<'de> serde::Deserialize<'de> for FilterNode {
5320 #[allow(deprecated)]
5321 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5322 where
5323 D: serde::Deserializer<'de>,
5324 {
5325 const FIELDS: &[&str] = &[
5326 "search_condition",
5327 "searchCondition",
5328 ];
5329
5330 #[allow(clippy::enum_variant_names)]
5331 enum GeneratedField {
5332 SearchCondition,
5333 }
5334 impl<'de> serde::Deserialize<'de> for GeneratedField {
5335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5336 where
5337 D: serde::Deserializer<'de>,
5338 {
5339 struct GeneratedVisitor;
5340
5341 impl serde::de::Visitor<'_> for GeneratedVisitor {
5342 type Value = GeneratedField;
5343
5344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5345 write!(formatter, "expected one of: {:?}", &FIELDS)
5346 }
5347
5348 #[allow(unused_variables)]
5349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5350 where
5351 E: serde::de::Error,
5352 {
5353 match value {
5354 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5355 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5356 }
5357 }
5358 }
5359 deserializer.deserialize_identifier(GeneratedVisitor)
5360 }
5361 }
5362 struct GeneratedVisitor;
5363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5364 type Value = FilterNode;
5365
5366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5367 formatter.write_str("struct stream_plan.FilterNode")
5368 }
5369
5370 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5371 where
5372 V: serde::de::MapAccess<'de>,
5373 {
5374 let mut search_condition__ = None;
5375 while let Some(k) = map_.next_key()? {
5376 match k {
5377 GeneratedField::SearchCondition => {
5378 if search_condition__.is_some() {
5379 return Err(serde::de::Error::duplicate_field("searchCondition"));
5380 }
5381 search_condition__ = map_.next_value()?;
5382 }
5383 }
5384 }
5385 Ok(FilterNode {
5386 search_condition: search_condition__,
5387 })
5388 }
5389 }
5390 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5391 }
5392}
5393impl serde::Serialize for GapFillNode {
5394 #[allow(deprecated)]
5395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5396 where
5397 S: serde::Serializer,
5398 {
5399 use serde::ser::SerializeStruct;
5400 let mut len = 0;
5401 if self.time_column_index != 0 {
5402 len += 1;
5403 }
5404 if self.interval.is_some() {
5405 len += 1;
5406 }
5407 if !self.fill_columns.is_empty() {
5408 len += 1;
5409 }
5410 if !self.fill_strategies.is_empty() {
5411 len += 1;
5412 }
5413 if self.state_table.is_some() {
5414 len += 1;
5415 }
5416 if !self.partition_by_indices.is_empty() {
5417 len += 1;
5418 }
5419 if !self.pointer_key_indices.is_empty() {
5420 len += 1;
5421 }
5422 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5423 if self.time_column_index != 0 {
5424 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5425 }
5426 if let Some(v) = self.interval.as_ref() {
5427 struct_ser.serialize_field("interval", v)?;
5428 }
5429 if !self.fill_columns.is_empty() {
5430 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5431 }
5432 if !self.fill_strategies.is_empty() {
5433 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5434 }
5435 if let Some(v) = self.state_table.as_ref() {
5436 struct_ser.serialize_field("stateTable", v)?;
5437 }
5438 if !self.partition_by_indices.is_empty() {
5439 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
5440 }
5441 if !self.pointer_key_indices.is_empty() {
5442 struct_ser.serialize_field("pointerKeyIndices", &self.pointer_key_indices)?;
5443 }
5444 struct_ser.end()
5445 }
5446}
5447impl<'de> serde::Deserialize<'de> for GapFillNode {
5448 #[allow(deprecated)]
5449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5450 where
5451 D: serde::Deserializer<'de>,
5452 {
5453 const FIELDS: &[&str] = &[
5454 "time_column_index",
5455 "timeColumnIndex",
5456 "interval",
5457 "fill_columns",
5458 "fillColumns",
5459 "fill_strategies",
5460 "fillStrategies",
5461 "state_table",
5462 "stateTable",
5463 "partition_by_indices",
5464 "partitionByIndices",
5465 "pointer_key_indices",
5466 "pointerKeyIndices",
5467 ];
5468
5469 #[allow(clippy::enum_variant_names)]
5470 enum GeneratedField {
5471 TimeColumnIndex,
5472 Interval,
5473 FillColumns,
5474 FillStrategies,
5475 StateTable,
5476 PartitionByIndices,
5477 PointerKeyIndices,
5478 }
5479 impl<'de> serde::Deserialize<'de> for GeneratedField {
5480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5481 where
5482 D: serde::Deserializer<'de>,
5483 {
5484 struct GeneratedVisitor;
5485
5486 impl serde::de::Visitor<'_> for GeneratedVisitor {
5487 type Value = GeneratedField;
5488
5489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5490 write!(formatter, "expected one of: {:?}", &FIELDS)
5491 }
5492
5493 #[allow(unused_variables)]
5494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5495 where
5496 E: serde::de::Error,
5497 {
5498 match value {
5499 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5500 "interval" => Ok(GeneratedField::Interval),
5501 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5502 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5503 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5504 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
5505 "pointerKeyIndices" | "pointer_key_indices" => Ok(GeneratedField::PointerKeyIndices),
5506 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5507 }
5508 }
5509 }
5510 deserializer.deserialize_identifier(GeneratedVisitor)
5511 }
5512 }
5513 struct GeneratedVisitor;
5514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5515 type Value = GapFillNode;
5516
5517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5518 formatter.write_str("struct stream_plan.GapFillNode")
5519 }
5520
5521 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5522 where
5523 V: serde::de::MapAccess<'de>,
5524 {
5525 let mut time_column_index__ = None;
5526 let mut interval__ = None;
5527 let mut fill_columns__ = None;
5528 let mut fill_strategies__ = None;
5529 let mut state_table__ = None;
5530 let mut partition_by_indices__ = None;
5531 let mut pointer_key_indices__ = None;
5532 while let Some(k) = map_.next_key()? {
5533 match k {
5534 GeneratedField::TimeColumnIndex => {
5535 if time_column_index__.is_some() {
5536 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5537 }
5538 time_column_index__ =
5539 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5540 ;
5541 }
5542 GeneratedField::Interval => {
5543 if interval__.is_some() {
5544 return Err(serde::de::Error::duplicate_field("interval"));
5545 }
5546 interval__ = map_.next_value()?;
5547 }
5548 GeneratedField::FillColumns => {
5549 if fill_columns__.is_some() {
5550 return Err(serde::de::Error::duplicate_field("fillColumns"));
5551 }
5552 fill_columns__ =
5553 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5554 .into_iter().map(|x| x.0).collect())
5555 ;
5556 }
5557 GeneratedField::FillStrategies => {
5558 if fill_strategies__.is_some() {
5559 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5560 }
5561 fill_strategies__ = Some(map_.next_value()?);
5562 }
5563 GeneratedField::StateTable => {
5564 if state_table__.is_some() {
5565 return Err(serde::de::Error::duplicate_field("stateTable"));
5566 }
5567 state_table__ = map_.next_value()?;
5568 }
5569 GeneratedField::PartitionByIndices => {
5570 if partition_by_indices__.is_some() {
5571 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
5572 }
5573 partition_by_indices__ =
5574 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5575 .into_iter().map(|x| x.0).collect())
5576 ;
5577 }
5578 GeneratedField::PointerKeyIndices => {
5579 if pointer_key_indices__.is_some() {
5580 return Err(serde::de::Error::duplicate_field("pointerKeyIndices"));
5581 }
5582 pointer_key_indices__ =
5583 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5584 .into_iter().map(|x| x.0).collect())
5585 ;
5586 }
5587 }
5588 }
5589 Ok(GapFillNode {
5590 time_column_index: time_column_index__.unwrap_or_default(),
5591 interval: interval__,
5592 fill_columns: fill_columns__.unwrap_or_default(),
5593 fill_strategies: fill_strategies__.unwrap_or_default(),
5594 state_table: state_table__,
5595 partition_by_indices: partition_by_indices__.unwrap_or_default(),
5596 pointer_key_indices: pointer_key_indices__.unwrap_or_default(),
5597 })
5598 }
5599 }
5600 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5601 }
5602}
5603impl serde::Serialize for GlobalApproxPercentileNode {
5604 #[allow(deprecated)]
5605 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5606 where
5607 S: serde::Serializer,
5608 {
5609 use serde::ser::SerializeStruct;
5610 let mut len = 0;
5611 if self.base != 0. {
5612 len += 1;
5613 }
5614 if self.quantile != 0. {
5615 len += 1;
5616 }
5617 if self.bucket_state_table.is_some() {
5618 len += 1;
5619 }
5620 if self.count_state_table.is_some() {
5621 len += 1;
5622 }
5623 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5624 if self.base != 0. {
5625 struct_ser.serialize_field("base", &self.base)?;
5626 }
5627 if self.quantile != 0. {
5628 struct_ser.serialize_field("quantile", &self.quantile)?;
5629 }
5630 if let Some(v) = self.bucket_state_table.as_ref() {
5631 struct_ser.serialize_field("bucketStateTable", v)?;
5632 }
5633 if let Some(v) = self.count_state_table.as_ref() {
5634 struct_ser.serialize_field("countStateTable", v)?;
5635 }
5636 struct_ser.end()
5637 }
5638}
5639impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5640 #[allow(deprecated)]
5641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5642 where
5643 D: serde::Deserializer<'de>,
5644 {
5645 const FIELDS: &[&str] = &[
5646 "base",
5647 "quantile",
5648 "bucket_state_table",
5649 "bucketStateTable",
5650 "count_state_table",
5651 "countStateTable",
5652 ];
5653
5654 #[allow(clippy::enum_variant_names)]
5655 enum GeneratedField {
5656 Base,
5657 Quantile,
5658 BucketStateTable,
5659 CountStateTable,
5660 }
5661 impl<'de> serde::Deserialize<'de> for GeneratedField {
5662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5663 where
5664 D: serde::Deserializer<'de>,
5665 {
5666 struct GeneratedVisitor;
5667
5668 impl serde::de::Visitor<'_> for GeneratedVisitor {
5669 type Value = GeneratedField;
5670
5671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5672 write!(formatter, "expected one of: {:?}", &FIELDS)
5673 }
5674
5675 #[allow(unused_variables)]
5676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5677 where
5678 E: serde::de::Error,
5679 {
5680 match value {
5681 "base" => Ok(GeneratedField::Base),
5682 "quantile" => Ok(GeneratedField::Quantile),
5683 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5684 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5685 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5686 }
5687 }
5688 }
5689 deserializer.deserialize_identifier(GeneratedVisitor)
5690 }
5691 }
5692 struct GeneratedVisitor;
5693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5694 type Value = GlobalApproxPercentileNode;
5695
5696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5697 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5698 }
5699
5700 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5701 where
5702 V: serde::de::MapAccess<'de>,
5703 {
5704 let mut base__ = None;
5705 let mut quantile__ = None;
5706 let mut bucket_state_table__ = None;
5707 let mut count_state_table__ = None;
5708 while let Some(k) = map_.next_key()? {
5709 match k {
5710 GeneratedField::Base => {
5711 if base__.is_some() {
5712 return Err(serde::de::Error::duplicate_field("base"));
5713 }
5714 base__ =
5715 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5716 ;
5717 }
5718 GeneratedField::Quantile => {
5719 if quantile__.is_some() {
5720 return Err(serde::de::Error::duplicate_field("quantile"));
5721 }
5722 quantile__ =
5723 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5724 ;
5725 }
5726 GeneratedField::BucketStateTable => {
5727 if bucket_state_table__.is_some() {
5728 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5729 }
5730 bucket_state_table__ = map_.next_value()?;
5731 }
5732 GeneratedField::CountStateTable => {
5733 if count_state_table__.is_some() {
5734 return Err(serde::de::Error::duplicate_field("countStateTable"));
5735 }
5736 count_state_table__ = map_.next_value()?;
5737 }
5738 }
5739 }
5740 Ok(GlobalApproxPercentileNode {
5741 base: base__.unwrap_or_default(),
5742 quantile: quantile__.unwrap_or_default(),
5743 bucket_state_table: bucket_state_table__,
5744 count_state_table: count_state_table__,
5745 })
5746 }
5747 }
5748 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5749 }
5750}
5751impl serde::Serialize for GroupTopNNode {
5752 #[allow(deprecated)]
5753 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5754 where
5755 S: serde::Serializer,
5756 {
5757 use serde::ser::SerializeStruct;
5758 let mut len = 0;
5759 if self.limit != 0 {
5760 len += 1;
5761 }
5762 if self.offset != 0 {
5763 len += 1;
5764 }
5765 if !self.group_key.is_empty() {
5766 len += 1;
5767 }
5768 if self.table.is_some() {
5769 len += 1;
5770 }
5771 if !self.order_by.is_empty() {
5772 len += 1;
5773 }
5774 if self.with_ties {
5775 len += 1;
5776 }
5777 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5778 if self.limit != 0 {
5779 #[allow(clippy::needless_borrow)]
5780 #[allow(clippy::needless_borrows_for_generic_args)]
5781 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5782 }
5783 if self.offset != 0 {
5784 #[allow(clippy::needless_borrow)]
5785 #[allow(clippy::needless_borrows_for_generic_args)]
5786 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5787 }
5788 if !self.group_key.is_empty() {
5789 struct_ser.serialize_field("groupKey", &self.group_key)?;
5790 }
5791 if let Some(v) = self.table.as_ref() {
5792 struct_ser.serialize_field("table", v)?;
5793 }
5794 if !self.order_by.is_empty() {
5795 struct_ser.serialize_field("orderBy", &self.order_by)?;
5796 }
5797 if self.with_ties {
5798 struct_ser.serialize_field("withTies", &self.with_ties)?;
5799 }
5800 struct_ser.end()
5801 }
5802}
5803impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5804 #[allow(deprecated)]
5805 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5806 where
5807 D: serde::Deserializer<'de>,
5808 {
5809 const FIELDS: &[&str] = &[
5810 "limit",
5811 "offset",
5812 "group_key",
5813 "groupKey",
5814 "table",
5815 "order_by",
5816 "orderBy",
5817 "with_ties",
5818 "withTies",
5819 ];
5820
5821 #[allow(clippy::enum_variant_names)]
5822 enum GeneratedField {
5823 Limit,
5824 Offset,
5825 GroupKey,
5826 Table,
5827 OrderBy,
5828 WithTies,
5829 }
5830 impl<'de> serde::Deserialize<'de> for GeneratedField {
5831 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5832 where
5833 D: serde::Deserializer<'de>,
5834 {
5835 struct GeneratedVisitor;
5836
5837 impl serde::de::Visitor<'_> for GeneratedVisitor {
5838 type Value = GeneratedField;
5839
5840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5841 write!(formatter, "expected one of: {:?}", &FIELDS)
5842 }
5843
5844 #[allow(unused_variables)]
5845 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5846 where
5847 E: serde::de::Error,
5848 {
5849 match value {
5850 "limit" => Ok(GeneratedField::Limit),
5851 "offset" => Ok(GeneratedField::Offset),
5852 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5853 "table" => Ok(GeneratedField::Table),
5854 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5855 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5856 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5857 }
5858 }
5859 }
5860 deserializer.deserialize_identifier(GeneratedVisitor)
5861 }
5862 }
5863 struct GeneratedVisitor;
5864 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5865 type Value = GroupTopNNode;
5866
5867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5868 formatter.write_str("struct stream_plan.GroupTopNNode")
5869 }
5870
5871 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5872 where
5873 V: serde::de::MapAccess<'de>,
5874 {
5875 let mut limit__ = None;
5876 let mut offset__ = None;
5877 let mut group_key__ = None;
5878 let mut table__ = None;
5879 let mut order_by__ = None;
5880 let mut with_ties__ = None;
5881 while let Some(k) = map_.next_key()? {
5882 match k {
5883 GeneratedField::Limit => {
5884 if limit__.is_some() {
5885 return Err(serde::de::Error::duplicate_field("limit"));
5886 }
5887 limit__ =
5888 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5889 ;
5890 }
5891 GeneratedField::Offset => {
5892 if offset__.is_some() {
5893 return Err(serde::de::Error::duplicate_field("offset"));
5894 }
5895 offset__ =
5896 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5897 ;
5898 }
5899 GeneratedField::GroupKey => {
5900 if group_key__.is_some() {
5901 return Err(serde::de::Error::duplicate_field("groupKey"));
5902 }
5903 group_key__ =
5904 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5905 .into_iter().map(|x| x.0).collect())
5906 ;
5907 }
5908 GeneratedField::Table => {
5909 if table__.is_some() {
5910 return Err(serde::de::Error::duplicate_field("table"));
5911 }
5912 table__ = map_.next_value()?;
5913 }
5914 GeneratedField::OrderBy => {
5915 if order_by__.is_some() {
5916 return Err(serde::de::Error::duplicate_field("orderBy"));
5917 }
5918 order_by__ = Some(map_.next_value()?);
5919 }
5920 GeneratedField::WithTies => {
5921 if with_ties__.is_some() {
5922 return Err(serde::de::Error::duplicate_field("withTies"));
5923 }
5924 with_ties__ = Some(map_.next_value()?);
5925 }
5926 }
5927 }
5928 Ok(GroupTopNNode {
5929 limit: limit__.unwrap_or_default(),
5930 offset: offset__.unwrap_or_default(),
5931 group_key: group_key__.unwrap_or_default(),
5932 table: table__,
5933 order_by: order_by__.unwrap_or_default(),
5934 with_ties: with_ties__.unwrap_or_default(),
5935 })
5936 }
5937 }
5938 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5939 }
5940}
5941impl serde::Serialize for HashAggNode {
5942 #[allow(deprecated)]
5943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5944 where
5945 S: serde::Serializer,
5946 {
5947 use serde::ser::SerializeStruct;
5948 let mut len = 0;
5949 if !self.group_key.is_empty() {
5950 len += 1;
5951 }
5952 if !self.agg_calls.is_empty() {
5953 len += 1;
5954 }
5955 if !self.agg_call_states.is_empty() {
5956 len += 1;
5957 }
5958 if self.intermediate_state_table.is_some() {
5959 len += 1;
5960 }
5961 if self.is_append_only {
5962 len += 1;
5963 }
5964 if !self.distinct_dedup_tables.is_empty() {
5965 len += 1;
5966 }
5967 if self.row_count_index != 0 {
5968 len += 1;
5969 }
5970 if self.emit_on_window_close {
5971 len += 1;
5972 }
5973 if self.version != 0 {
5974 len += 1;
5975 }
5976 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5977 if !self.group_key.is_empty() {
5978 struct_ser.serialize_field("groupKey", &self.group_key)?;
5979 }
5980 if !self.agg_calls.is_empty() {
5981 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5982 }
5983 if !self.agg_call_states.is_empty() {
5984 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5985 }
5986 if let Some(v) = self.intermediate_state_table.as_ref() {
5987 struct_ser.serialize_field("intermediateStateTable", v)?;
5988 }
5989 if self.is_append_only {
5990 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5991 }
5992 if !self.distinct_dedup_tables.is_empty() {
5993 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5994 }
5995 if self.row_count_index != 0 {
5996 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5997 }
5998 if self.emit_on_window_close {
5999 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
6000 }
6001 if self.version != 0 {
6002 let v = AggNodeVersion::try_from(self.version)
6003 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
6004 struct_ser.serialize_field("version", &v)?;
6005 }
6006 struct_ser.end()
6007 }
6008}
6009impl<'de> serde::Deserialize<'de> for HashAggNode {
6010 #[allow(deprecated)]
6011 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6012 where
6013 D: serde::Deserializer<'de>,
6014 {
6015 const FIELDS: &[&str] = &[
6016 "group_key",
6017 "groupKey",
6018 "agg_calls",
6019 "aggCalls",
6020 "agg_call_states",
6021 "aggCallStates",
6022 "intermediate_state_table",
6023 "intermediateStateTable",
6024 "is_append_only",
6025 "isAppendOnly",
6026 "distinct_dedup_tables",
6027 "distinctDedupTables",
6028 "row_count_index",
6029 "rowCountIndex",
6030 "emit_on_window_close",
6031 "emitOnWindowClose",
6032 "version",
6033 ];
6034
6035 #[allow(clippy::enum_variant_names)]
6036 enum GeneratedField {
6037 GroupKey,
6038 AggCalls,
6039 AggCallStates,
6040 IntermediateStateTable,
6041 IsAppendOnly,
6042 DistinctDedupTables,
6043 RowCountIndex,
6044 EmitOnWindowClose,
6045 Version,
6046 }
6047 impl<'de> serde::Deserialize<'de> for GeneratedField {
6048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6049 where
6050 D: serde::Deserializer<'de>,
6051 {
6052 struct GeneratedVisitor;
6053
6054 impl serde::de::Visitor<'_> for GeneratedVisitor {
6055 type Value = GeneratedField;
6056
6057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6058 write!(formatter, "expected one of: {:?}", &FIELDS)
6059 }
6060
6061 #[allow(unused_variables)]
6062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6063 where
6064 E: serde::de::Error,
6065 {
6066 match value {
6067 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6068 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6069 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
6070 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
6071 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6072 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
6073 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
6074 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
6075 "version" => Ok(GeneratedField::Version),
6076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6077 }
6078 }
6079 }
6080 deserializer.deserialize_identifier(GeneratedVisitor)
6081 }
6082 }
6083 struct GeneratedVisitor;
6084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6085 type Value = HashAggNode;
6086
6087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6088 formatter.write_str("struct stream_plan.HashAggNode")
6089 }
6090
6091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
6092 where
6093 V: serde::de::MapAccess<'de>,
6094 {
6095 let mut group_key__ = None;
6096 let mut agg_calls__ = None;
6097 let mut agg_call_states__ = None;
6098 let mut intermediate_state_table__ = None;
6099 let mut is_append_only__ = None;
6100 let mut distinct_dedup_tables__ = None;
6101 let mut row_count_index__ = None;
6102 let mut emit_on_window_close__ = None;
6103 let mut version__ = None;
6104 while let Some(k) = map_.next_key()? {
6105 match k {
6106 GeneratedField::GroupKey => {
6107 if group_key__.is_some() {
6108 return Err(serde::de::Error::duplicate_field("groupKey"));
6109 }
6110 group_key__ =
6111 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6112 .into_iter().map(|x| x.0).collect())
6113 ;
6114 }
6115 GeneratedField::AggCalls => {
6116 if agg_calls__.is_some() {
6117 return Err(serde::de::Error::duplicate_field("aggCalls"));
6118 }
6119 agg_calls__ = Some(map_.next_value()?);
6120 }
6121 GeneratedField::AggCallStates => {
6122 if agg_call_states__.is_some() {
6123 return Err(serde::de::Error::duplicate_field("aggCallStates"));
6124 }
6125 agg_call_states__ = Some(map_.next_value()?);
6126 }
6127 GeneratedField::IntermediateStateTable => {
6128 if intermediate_state_table__.is_some() {
6129 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
6130 }
6131 intermediate_state_table__ = map_.next_value()?;
6132 }
6133 GeneratedField::IsAppendOnly => {
6134 if is_append_only__.is_some() {
6135 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6136 }
6137 is_append_only__ = Some(map_.next_value()?);
6138 }
6139 GeneratedField::DistinctDedupTables => {
6140 if distinct_dedup_tables__.is_some() {
6141 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
6142 }
6143 distinct_dedup_tables__ = Some(
6144 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6145 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6146 );
6147 }
6148 GeneratedField::RowCountIndex => {
6149 if row_count_index__.is_some() {
6150 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
6151 }
6152 row_count_index__ =
6153 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6154 ;
6155 }
6156 GeneratedField::EmitOnWindowClose => {
6157 if emit_on_window_close__.is_some() {
6158 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
6159 }
6160 emit_on_window_close__ = Some(map_.next_value()?);
6161 }
6162 GeneratedField::Version => {
6163 if version__.is_some() {
6164 return Err(serde::de::Error::duplicate_field("version"));
6165 }
6166 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
6167 }
6168 }
6169 }
6170 Ok(HashAggNode {
6171 group_key: group_key__.unwrap_or_default(),
6172 agg_calls: agg_calls__.unwrap_or_default(),
6173 agg_call_states: agg_call_states__.unwrap_or_default(),
6174 intermediate_state_table: intermediate_state_table__,
6175 is_append_only: is_append_only__.unwrap_or_default(),
6176 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
6177 row_count_index: row_count_index__.unwrap_or_default(),
6178 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
6179 version: version__.unwrap_or_default(),
6180 })
6181 }
6182 }
6183 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
6184 }
6185}
6186impl serde::Serialize for HashJoinNode {
6187 #[allow(deprecated)]
6188 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6189 where
6190 S: serde::Serializer,
6191 {
6192 use serde::ser::SerializeStruct;
6193 let mut len = 0;
6194 if self.join_type != 0 {
6195 len += 1;
6196 }
6197 if !self.left_key.is_empty() {
6198 len += 1;
6199 }
6200 if !self.right_key.is_empty() {
6201 len += 1;
6202 }
6203 if self.condition.is_some() {
6204 len += 1;
6205 }
6206 if self.left_table.is_some() {
6207 len += 1;
6208 }
6209 if self.right_table.is_some() {
6210 len += 1;
6211 }
6212 if self.left_degree_table.is_some() {
6213 len += 1;
6214 }
6215 if self.right_degree_table.is_some() {
6216 len += 1;
6217 }
6218 if !self.output_indices.is_empty() {
6219 len += 1;
6220 }
6221 if !self.left_deduped_input_pk_indices.is_empty() {
6222 len += 1;
6223 }
6224 if !self.right_deduped_input_pk_indices.is_empty() {
6225 len += 1;
6226 }
6227 if !self.null_safe.is_empty() {
6228 len += 1;
6229 }
6230 if self.is_append_only {
6231 len += 1;
6232 }
6233 if self.join_encoding_type != 0 {
6234 len += 1;
6235 }
6236 if self.watermark_handle_desc.is_some() {
6237 len += 1;
6238 }
6239 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
6240 if self.join_type != 0 {
6241 let v = super::plan_common::JoinType::try_from(self.join_type)
6242 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6243 struct_ser.serialize_field("joinType", &v)?;
6244 }
6245 if !self.left_key.is_empty() {
6246 struct_ser.serialize_field("leftKey", &self.left_key)?;
6247 }
6248 if !self.right_key.is_empty() {
6249 struct_ser.serialize_field("rightKey", &self.right_key)?;
6250 }
6251 if let Some(v) = self.condition.as_ref() {
6252 struct_ser.serialize_field("condition", v)?;
6253 }
6254 if let Some(v) = self.left_table.as_ref() {
6255 struct_ser.serialize_field("leftTable", v)?;
6256 }
6257 if let Some(v) = self.right_table.as_ref() {
6258 struct_ser.serialize_field("rightTable", v)?;
6259 }
6260 if let Some(v) = self.left_degree_table.as_ref() {
6261 struct_ser.serialize_field("leftDegreeTable", v)?;
6262 }
6263 if let Some(v) = self.right_degree_table.as_ref() {
6264 struct_ser.serialize_field("rightDegreeTable", v)?;
6265 }
6266 if !self.output_indices.is_empty() {
6267 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6268 }
6269 if !self.left_deduped_input_pk_indices.is_empty() {
6270 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
6271 }
6272 if !self.right_deduped_input_pk_indices.is_empty() {
6273 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
6274 }
6275 if !self.null_safe.is_empty() {
6276 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
6277 }
6278 if self.is_append_only {
6279 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
6280 }
6281 if self.join_encoding_type != 0 {
6282 let v = JoinEncodingType::try_from(self.join_encoding_type)
6283 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
6284 struct_ser.serialize_field("joinEncodingType", &v)?;
6285 }
6286 if let Some(v) = self.watermark_handle_desc.as_ref() {
6287 struct_ser.serialize_field("watermarkHandleDesc", v)?;
6288 }
6289 struct_ser.end()
6290 }
6291}
6292impl<'de> serde::Deserialize<'de> for HashJoinNode {
6293 #[allow(deprecated)]
6294 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6295 where
6296 D: serde::Deserializer<'de>,
6297 {
6298 const FIELDS: &[&str] = &[
6299 "join_type",
6300 "joinType",
6301 "left_key",
6302 "leftKey",
6303 "right_key",
6304 "rightKey",
6305 "condition",
6306 "left_table",
6307 "leftTable",
6308 "right_table",
6309 "rightTable",
6310 "left_degree_table",
6311 "leftDegreeTable",
6312 "right_degree_table",
6313 "rightDegreeTable",
6314 "output_indices",
6315 "outputIndices",
6316 "left_deduped_input_pk_indices",
6317 "leftDedupedInputPkIndices",
6318 "right_deduped_input_pk_indices",
6319 "rightDedupedInputPkIndices",
6320 "null_safe",
6321 "nullSafe",
6322 "is_append_only",
6323 "isAppendOnly",
6324 "join_encoding_type",
6325 "joinEncodingType",
6326 "watermark_handle_desc",
6327 "watermarkHandleDesc",
6328 ];
6329
6330 #[allow(clippy::enum_variant_names)]
6331 enum GeneratedField {
6332 JoinType,
6333 LeftKey,
6334 RightKey,
6335 Condition,
6336 LeftTable,
6337 RightTable,
6338 LeftDegreeTable,
6339 RightDegreeTable,
6340 OutputIndices,
6341 LeftDedupedInputPkIndices,
6342 RightDedupedInputPkIndices,
6343 NullSafe,
6344 IsAppendOnly,
6345 JoinEncodingType,
6346 WatermarkHandleDesc,
6347 }
6348 impl<'de> serde::Deserialize<'de> for GeneratedField {
6349 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6350 where
6351 D: serde::Deserializer<'de>,
6352 {
6353 struct GeneratedVisitor;
6354
6355 impl serde::de::Visitor<'_> for GeneratedVisitor {
6356 type Value = GeneratedField;
6357
6358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6359 write!(formatter, "expected one of: {:?}", &FIELDS)
6360 }
6361
6362 #[allow(unused_variables)]
6363 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6364 where
6365 E: serde::de::Error,
6366 {
6367 match value {
6368 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6369 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6370 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6371 "condition" => Ok(GeneratedField::Condition),
6372 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
6373 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
6374 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
6375 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
6376 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6377 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
6378 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
6379 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
6380 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6381 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
6382 "watermarkHandleDesc" | "watermark_handle_desc" => Ok(GeneratedField::WatermarkHandleDesc),
6383 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6384 }
6385 }
6386 }
6387 deserializer.deserialize_identifier(GeneratedVisitor)
6388 }
6389 }
6390 struct GeneratedVisitor;
6391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6392 type Value = HashJoinNode;
6393
6394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6395 formatter.write_str("struct stream_plan.HashJoinNode")
6396 }
6397
6398 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6399 where
6400 V: serde::de::MapAccess<'de>,
6401 {
6402 let mut join_type__ = None;
6403 let mut left_key__ = None;
6404 let mut right_key__ = None;
6405 let mut condition__ = None;
6406 let mut left_table__ = None;
6407 let mut right_table__ = None;
6408 let mut left_degree_table__ = None;
6409 let mut right_degree_table__ = None;
6410 let mut output_indices__ = None;
6411 let mut left_deduped_input_pk_indices__ = None;
6412 let mut right_deduped_input_pk_indices__ = None;
6413 let mut null_safe__ = None;
6414 let mut is_append_only__ = None;
6415 let mut join_encoding_type__ = None;
6416 let mut watermark_handle_desc__ = None;
6417 while let Some(k) = map_.next_key()? {
6418 match k {
6419 GeneratedField::JoinType => {
6420 if join_type__.is_some() {
6421 return Err(serde::de::Error::duplicate_field("joinType"));
6422 }
6423 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6424 }
6425 GeneratedField::LeftKey => {
6426 if left_key__.is_some() {
6427 return Err(serde::de::Error::duplicate_field("leftKey"));
6428 }
6429 left_key__ =
6430 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6431 .into_iter().map(|x| x.0).collect())
6432 ;
6433 }
6434 GeneratedField::RightKey => {
6435 if right_key__.is_some() {
6436 return Err(serde::de::Error::duplicate_field("rightKey"));
6437 }
6438 right_key__ =
6439 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6440 .into_iter().map(|x| x.0).collect())
6441 ;
6442 }
6443 GeneratedField::Condition => {
6444 if condition__.is_some() {
6445 return Err(serde::de::Error::duplicate_field("condition"));
6446 }
6447 condition__ = map_.next_value()?;
6448 }
6449 GeneratedField::LeftTable => {
6450 if left_table__.is_some() {
6451 return Err(serde::de::Error::duplicate_field("leftTable"));
6452 }
6453 left_table__ = map_.next_value()?;
6454 }
6455 GeneratedField::RightTable => {
6456 if right_table__.is_some() {
6457 return Err(serde::de::Error::duplicate_field("rightTable"));
6458 }
6459 right_table__ = map_.next_value()?;
6460 }
6461 GeneratedField::LeftDegreeTable => {
6462 if left_degree_table__.is_some() {
6463 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6464 }
6465 left_degree_table__ = map_.next_value()?;
6466 }
6467 GeneratedField::RightDegreeTable => {
6468 if right_degree_table__.is_some() {
6469 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6470 }
6471 right_degree_table__ = map_.next_value()?;
6472 }
6473 GeneratedField::OutputIndices => {
6474 if output_indices__.is_some() {
6475 return Err(serde::de::Error::duplicate_field("outputIndices"));
6476 }
6477 output_indices__ =
6478 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6479 .into_iter().map(|x| x.0).collect())
6480 ;
6481 }
6482 GeneratedField::LeftDedupedInputPkIndices => {
6483 if left_deduped_input_pk_indices__.is_some() {
6484 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6485 }
6486 left_deduped_input_pk_indices__ =
6487 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6488 .into_iter().map(|x| x.0).collect())
6489 ;
6490 }
6491 GeneratedField::RightDedupedInputPkIndices => {
6492 if right_deduped_input_pk_indices__.is_some() {
6493 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6494 }
6495 right_deduped_input_pk_indices__ =
6496 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6497 .into_iter().map(|x| x.0).collect())
6498 ;
6499 }
6500 GeneratedField::NullSafe => {
6501 if null_safe__.is_some() {
6502 return Err(serde::de::Error::duplicate_field("nullSafe"));
6503 }
6504 null_safe__ = Some(map_.next_value()?);
6505 }
6506 GeneratedField::IsAppendOnly => {
6507 if is_append_only__.is_some() {
6508 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6509 }
6510 is_append_only__ = Some(map_.next_value()?);
6511 }
6512 GeneratedField::JoinEncodingType => {
6513 if join_encoding_type__.is_some() {
6514 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6515 }
6516 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6517 }
6518 GeneratedField::WatermarkHandleDesc => {
6519 if watermark_handle_desc__.is_some() {
6520 return Err(serde::de::Error::duplicate_field("watermarkHandleDesc"));
6521 }
6522 watermark_handle_desc__ = map_.next_value()?;
6523 }
6524 }
6525 }
6526 Ok(HashJoinNode {
6527 join_type: join_type__.unwrap_or_default(),
6528 left_key: left_key__.unwrap_or_default(),
6529 right_key: right_key__.unwrap_or_default(),
6530 condition: condition__,
6531 left_table: left_table__,
6532 right_table: right_table__,
6533 left_degree_table: left_degree_table__,
6534 right_degree_table: right_degree_table__,
6535 output_indices: output_indices__.unwrap_or_default(),
6536 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6537 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6538 null_safe: null_safe__.unwrap_or_default(),
6539 is_append_only: is_append_only__.unwrap_or_default(),
6540 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6541 watermark_handle_desc: watermark_handle_desc__,
6542 })
6543 }
6544 }
6545 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6546 }
6547}
6548impl serde::Serialize for HashJoinWatermarkHandleDesc {
6549 #[allow(deprecated)]
6550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6551 where
6552 S: serde::Serializer,
6553 {
6554 use serde::ser::SerializeStruct;
6555 let mut len = 0;
6556 if !self.watermark_indices_in_jk.is_empty() {
6557 len += 1;
6558 }
6559 if !self.inequality_pairs.is_empty() {
6560 len += 1;
6561 }
6562 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinWatermarkHandleDesc", len)?;
6563 if !self.watermark_indices_in_jk.is_empty() {
6564 struct_ser.serialize_field("watermarkIndicesInJk", &self.watermark_indices_in_jk)?;
6565 }
6566 if !self.inequality_pairs.is_empty() {
6567 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
6568 }
6569 struct_ser.end()
6570 }
6571}
6572impl<'de> serde::Deserialize<'de> for HashJoinWatermarkHandleDesc {
6573 #[allow(deprecated)]
6574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6575 where
6576 D: serde::Deserializer<'de>,
6577 {
6578 const FIELDS: &[&str] = &[
6579 "watermark_indices_in_jk",
6580 "watermarkIndicesInJk",
6581 "inequality_pairs",
6582 "inequalityPairs",
6583 ];
6584
6585 #[allow(clippy::enum_variant_names)]
6586 enum GeneratedField {
6587 WatermarkIndicesInJk,
6588 InequalityPairs,
6589 }
6590 impl<'de> serde::Deserialize<'de> for GeneratedField {
6591 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6592 where
6593 D: serde::Deserializer<'de>,
6594 {
6595 struct GeneratedVisitor;
6596
6597 impl serde::de::Visitor<'_> for GeneratedVisitor {
6598 type Value = GeneratedField;
6599
6600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6601 write!(formatter, "expected one of: {:?}", &FIELDS)
6602 }
6603
6604 #[allow(unused_variables)]
6605 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6606 where
6607 E: serde::de::Error,
6608 {
6609 match value {
6610 "watermarkIndicesInJk" | "watermark_indices_in_jk" => Ok(GeneratedField::WatermarkIndicesInJk),
6611 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
6612 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6613 }
6614 }
6615 }
6616 deserializer.deserialize_identifier(GeneratedVisitor)
6617 }
6618 }
6619 struct GeneratedVisitor;
6620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6621 type Value = HashJoinWatermarkHandleDesc;
6622
6623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6624 formatter.write_str("struct stream_plan.HashJoinWatermarkHandleDesc")
6625 }
6626
6627 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinWatermarkHandleDesc, V::Error>
6628 where
6629 V: serde::de::MapAccess<'de>,
6630 {
6631 let mut watermark_indices_in_jk__ = None;
6632 let mut inequality_pairs__ = None;
6633 while let Some(k) = map_.next_key()? {
6634 match k {
6635 GeneratedField::WatermarkIndicesInJk => {
6636 if watermark_indices_in_jk__.is_some() {
6637 return Err(serde::de::Error::duplicate_field("watermarkIndicesInJk"));
6638 }
6639 watermark_indices_in_jk__ = Some(map_.next_value()?);
6640 }
6641 GeneratedField::InequalityPairs => {
6642 if inequality_pairs__.is_some() {
6643 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6644 }
6645 inequality_pairs__ = Some(map_.next_value()?);
6646 }
6647 }
6648 }
6649 Ok(HashJoinWatermarkHandleDesc {
6650 watermark_indices_in_jk: watermark_indices_in_jk__.unwrap_or_default(),
6651 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6652 })
6653 }
6654 }
6655 deserializer.deserialize_struct("stream_plan.HashJoinWatermarkHandleDesc", FIELDS, GeneratedVisitor)
6656 }
6657}
6658impl serde::Serialize for HopWindowNode {
6659 #[allow(deprecated)]
6660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6661 where
6662 S: serde::Serializer,
6663 {
6664 use serde::ser::SerializeStruct;
6665 let mut len = 0;
6666 if self.time_col != 0 {
6667 len += 1;
6668 }
6669 if self.window_slide.is_some() {
6670 len += 1;
6671 }
6672 if self.window_size.is_some() {
6673 len += 1;
6674 }
6675 if !self.output_indices.is_empty() {
6676 len += 1;
6677 }
6678 if !self.window_start_exprs.is_empty() {
6679 len += 1;
6680 }
6681 if !self.window_end_exprs.is_empty() {
6682 len += 1;
6683 }
6684 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6685 if self.time_col != 0 {
6686 struct_ser.serialize_field("timeCol", &self.time_col)?;
6687 }
6688 if let Some(v) = self.window_slide.as_ref() {
6689 struct_ser.serialize_field("windowSlide", v)?;
6690 }
6691 if let Some(v) = self.window_size.as_ref() {
6692 struct_ser.serialize_field("windowSize", v)?;
6693 }
6694 if !self.output_indices.is_empty() {
6695 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6696 }
6697 if !self.window_start_exprs.is_empty() {
6698 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6699 }
6700 if !self.window_end_exprs.is_empty() {
6701 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6702 }
6703 struct_ser.end()
6704 }
6705}
6706impl<'de> serde::Deserialize<'de> for HopWindowNode {
6707 #[allow(deprecated)]
6708 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6709 where
6710 D: serde::Deserializer<'de>,
6711 {
6712 const FIELDS: &[&str] = &[
6713 "time_col",
6714 "timeCol",
6715 "window_slide",
6716 "windowSlide",
6717 "window_size",
6718 "windowSize",
6719 "output_indices",
6720 "outputIndices",
6721 "window_start_exprs",
6722 "windowStartExprs",
6723 "window_end_exprs",
6724 "windowEndExprs",
6725 ];
6726
6727 #[allow(clippy::enum_variant_names)]
6728 enum GeneratedField {
6729 TimeCol,
6730 WindowSlide,
6731 WindowSize,
6732 OutputIndices,
6733 WindowStartExprs,
6734 WindowEndExprs,
6735 }
6736 impl<'de> serde::Deserialize<'de> for GeneratedField {
6737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6738 where
6739 D: serde::Deserializer<'de>,
6740 {
6741 struct GeneratedVisitor;
6742
6743 impl serde::de::Visitor<'_> for GeneratedVisitor {
6744 type Value = GeneratedField;
6745
6746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6747 write!(formatter, "expected one of: {:?}", &FIELDS)
6748 }
6749
6750 #[allow(unused_variables)]
6751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6752 where
6753 E: serde::de::Error,
6754 {
6755 match value {
6756 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6757 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6758 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6759 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6760 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6761 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6763 }
6764 }
6765 }
6766 deserializer.deserialize_identifier(GeneratedVisitor)
6767 }
6768 }
6769 struct GeneratedVisitor;
6770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6771 type Value = HopWindowNode;
6772
6773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6774 formatter.write_str("struct stream_plan.HopWindowNode")
6775 }
6776
6777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6778 where
6779 V: serde::de::MapAccess<'de>,
6780 {
6781 let mut time_col__ = None;
6782 let mut window_slide__ = None;
6783 let mut window_size__ = None;
6784 let mut output_indices__ = None;
6785 let mut window_start_exprs__ = None;
6786 let mut window_end_exprs__ = None;
6787 while let Some(k) = map_.next_key()? {
6788 match k {
6789 GeneratedField::TimeCol => {
6790 if time_col__.is_some() {
6791 return Err(serde::de::Error::duplicate_field("timeCol"));
6792 }
6793 time_col__ =
6794 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6795 ;
6796 }
6797 GeneratedField::WindowSlide => {
6798 if window_slide__.is_some() {
6799 return Err(serde::de::Error::duplicate_field("windowSlide"));
6800 }
6801 window_slide__ = map_.next_value()?;
6802 }
6803 GeneratedField::WindowSize => {
6804 if window_size__.is_some() {
6805 return Err(serde::de::Error::duplicate_field("windowSize"));
6806 }
6807 window_size__ = map_.next_value()?;
6808 }
6809 GeneratedField::OutputIndices => {
6810 if output_indices__.is_some() {
6811 return Err(serde::de::Error::duplicate_field("outputIndices"));
6812 }
6813 output_indices__ =
6814 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6815 .into_iter().map(|x| x.0).collect())
6816 ;
6817 }
6818 GeneratedField::WindowStartExprs => {
6819 if window_start_exprs__.is_some() {
6820 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6821 }
6822 window_start_exprs__ = Some(map_.next_value()?);
6823 }
6824 GeneratedField::WindowEndExprs => {
6825 if window_end_exprs__.is_some() {
6826 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6827 }
6828 window_end_exprs__ = Some(map_.next_value()?);
6829 }
6830 }
6831 }
6832 Ok(HopWindowNode {
6833 time_col: time_col__.unwrap_or_default(),
6834 window_slide: window_slide__,
6835 window_size: window_size__,
6836 output_indices: output_indices__.unwrap_or_default(),
6837 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6838 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6839 })
6840 }
6841 }
6842 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6843 }
6844}
6845impl serde::Serialize for IcebergPkIndexCompactionContext {
6846 #[allow(deprecated)]
6847 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6848 where
6849 S: serde::Serializer,
6850 {
6851 use serde::ser::SerializeStruct;
6852 let mut len = 0;
6853 if self.sink_id != 0 {
6854 len += 1;
6855 }
6856 if self.task_id != 0 {
6857 len += 1;
6858 }
6859 if self.phase != 0 {
6860 len += 1;
6861 }
6862 if self.resolver_task_input.is_some() {
6863 len += 1;
6864 }
6865 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergPkIndexCompactionContext", len)?;
6866 if self.sink_id != 0 {
6867 struct_ser.serialize_field("sinkId", &self.sink_id)?;
6868 }
6869 if self.task_id != 0 {
6870 #[allow(clippy::needless_borrow)]
6871 #[allow(clippy::needless_borrows_for_generic_args)]
6872 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
6873 }
6874 if self.phase != 0 {
6875 let v = iceberg_pk_index_compaction_context::Phase::try_from(self.phase)
6876 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.phase)))?;
6877 struct_ser.serialize_field("phase", &v)?;
6878 }
6879 if let Some(v) = self.resolver_task_input.as_ref() {
6880 struct_ser.serialize_field("resolverTaskInput", v)?;
6881 }
6882 struct_ser.end()
6883 }
6884}
6885impl<'de> serde::Deserialize<'de> for IcebergPkIndexCompactionContext {
6886 #[allow(deprecated)]
6887 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6888 where
6889 D: serde::Deserializer<'de>,
6890 {
6891 const FIELDS: &[&str] = &[
6892 "sink_id",
6893 "sinkId",
6894 "task_id",
6895 "taskId",
6896 "phase",
6897 "resolver_task_input",
6898 "resolverTaskInput",
6899 ];
6900
6901 #[allow(clippy::enum_variant_names)]
6902 enum GeneratedField {
6903 SinkId,
6904 TaskId,
6905 Phase,
6906 ResolverTaskInput,
6907 }
6908 impl<'de> serde::Deserialize<'de> for GeneratedField {
6909 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6910 where
6911 D: serde::Deserializer<'de>,
6912 {
6913 struct GeneratedVisitor;
6914
6915 impl serde::de::Visitor<'_> for GeneratedVisitor {
6916 type Value = GeneratedField;
6917
6918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6919 write!(formatter, "expected one of: {:?}", &FIELDS)
6920 }
6921
6922 #[allow(unused_variables)]
6923 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6924 where
6925 E: serde::de::Error,
6926 {
6927 match value {
6928 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
6929 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
6930 "phase" => Ok(GeneratedField::Phase),
6931 "resolverTaskInput" | "resolver_task_input" => Ok(GeneratedField::ResolverTaskInput),
6932 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6933 }
6934 }
6935 }
6936 deserializer.deserialize_identifier(GeneratedVisitor)
6937 }
6938 }
6939 struct GeneratedVisitor;
6940 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6941 type Value = IcebergPkIndexCompactionContext;
6942
6943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6944 formatter.write_str("struct stream_plan.IcebergPkIndexCompactionContext")
6945 }
6946
6947 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergPkIndexCompactionContext, V::Error>
6948 where
6949 V: serde::de::MapAccess<'de>,
6950 {
6951 let mut sink_id__ = None;
6952 let mut task_id__ = None;
6953 let mut phase__ = None;
6954 let mut resolver_task_input__ = None;
6955 while let Some(k) = map_.next_key()? {
6956 match k {
6957 GeneratedField::SinkId => {
6958 if sink_id__.is_some() {
6959 return Err(serde::de::Error::duplicate_field("sinkId"));
6960 }
6961 sink_id__ =
6962 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6963 ;
6964 }
6965 GeneratedField::TaskId => {
6966 if task_id__.is_some() {
6967 return Err(serde::de::Error::duplicate_field("taskId"));
6968 }
6969 task_id__ =
6970 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6971 ;
6972 }
6973 GeneratedField::Phase => {
6974 if phase__.is_some() {
6975 return Err(serde::de::Error::duplicate_field("phase"));
6976 }
6977 phase__ = Some(map_.next_value::<iceberg_pk_index_compaction_context::Phase>()? as i32);
6978 }
6979 GeneratedField::ResolverTaskInput => {
6980 if resolver_task_input__.is_some() {
6981 return Err(serde::de::Error::duplicate_field("resolverTaskInput"));
6982 }
6983 resolver_task_input__ = map_.next_value()?;
6984 }
6985 }
6986 }
6987 Ok(IcebergPkIndexCompactionContext {
6988 sink_id: sink_id__.unwrap_or_default(),
6989 task_id: task_id__.unwrap_or_default(),
6990 phase: phase__.unwrap_or_default(),
6991 resolver_task_input: resolver_task_input__,
6992 })
6993 }
6994 }
6995 deserializer.deserialize_struct("stream_plan.IcebergPkIndexCompactionContext", FIELDS, GeneratedVisitor)
6996 }
6997}
6998impl serde::Serialize for iceberg_pk_index_compaction_context::Phase {
6999 #[allow(deprecated)]
7000 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7001 where
7002 S: serde::Serializer,
7003 {
7004 let variant = match self {
7005 Self::Unspecified => "PHASE_UNSPECIFIED",
7006 Self::Begin => "PHASE_BEGIN",
7007 Self::End => "PHASE_END",
7008 };
7009 serializer.serialize_str(variant)
7010 }
7011}
7012impl<'de> serde::Deserialize<'de> for iceberg_pk_index_compaction_context::Phase {
7013 #[allow(deprecated)]
7014 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7015 where
7016 D: serde::Deserializer<'de>,
7017 {
7018 const FIELDS: &[&str] = &[
7019 "PHASE_UNSPECIFIED",
7020 "PHASE_BEGIN",
7021 "PHASE_END",
7022 ];
7023
7024 struct GeneratedVisitor;
7025
7026 impl serde::de::Visitor<'_> for GeneratedVisitor {
7027 type Value = iceberg_pk_index_compaction_context::Phase;
7028
7029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7030 write!(formatter, "expected one of: {:?}", &FIELDS)
7031 }
7032
7033 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7034 where
7035 E: serde::de::Error,
7036 {
7037 i32::try_from(v)
7038 .ok()
7039 .and_then(|x| x.try_into().ok())
7040 .ok_or_else(|| {
7041 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7042 })
7043 }
7044
7045 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7046 where
7047 E: serde::de::Error,
7048 {
7049 i32::try_from(v)
7050 .ok()
7051 .and_then(|x| x.try_into().ok())
7052 .ok_or_else(|| {
7053 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7054 })
7055 }
7056
7057 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7058 where
7059 E: serde::de::Error,
7060 {
7061 match value {
7062 "PHASE_UNSPECIFIED" => Ok(iceberg_pk_index_compaction_context::Phase::Unspecified),
7063 "PHASE_BEGIN" => Ok(iceberg_pk_index_compaction_context::Phase::Begin),
7064 "PHASE_END" => Ok(iceberg_pk_index_compaction_context::Phase::End),
7065 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7066 }
7067 }
7068 }
7069 deserializer.deserialize_any(GeneratedVisitor)
7070 }
7071}
7072impl serde::Serialize for iceberg_pk_index_compaction_context::ResolverTaskInput {
7073 #[allow(deprecated)]
7074 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7075 where
7076 S: serde::Serializer,
7077 {
7078 use serde::ser::SerializeStruct;
7079 let mut len = 0;
7080 if !self.output_data_file_paths.is_empty() {
7081 len += 1;
7082 }
7083 if !self.input_data_file_paths.is_empty() {
7084 len += 1;
7085 }
7086 if self.read_snapshot_id != 0 {
7087 len += 1;
7088 }
7089 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergPkIndexCompactionContext.ResolverTaskInput", len)?;
7090 if !self.output_data_file_paths.is_empty() {
7091 struct_ser.serialize_field("outputDataFilePaths", &self.output_data_file_paths)?;
7092 }
7093 if !self.input_data_file_paths.is_empty() {
7094 struct_ser.serialize_field("inputDataFilePaths", &self.input_data_file_paths)?;
7095 }
7096 if self.read_snapshot_id != 0 {
7097 #[allow(clippy::needless_borrow)]
7098 #[allow(clippy::needless_borrows_for_generic_args)]
7099 struct_ser.serialize_field("readSnapshotId", ToString::to_string(&self.read_snapshot_id).as_str())?;
7100 }
7101 struct_ser.end()
7102 }
7103}
7104impl<'de> serde::Deserialize<'de> for iceberg_pk_index_compaction_context::ResolverTaskInput {
7105 #[allow(deprecated)]
7106 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7107 where
7108 D: serde::Deserializer<'de>,
7109 {
7110 const FIELDS: &[&str] = &[
7111 "output_data_file_paths",
7112 "outputDataFilePaths",
7113 "input_data_file_paths",
7114 "inputDataFilePaths",
7115 "read_snapshot_id",
7116 "readSnapshotId",
7117 ];
7118
7119 #[allow(clippy::enum_variant_names)]
7120 enum GeneratedField {
7121 OutputDataFilePaths,
7122 InputDataFilePaths,
7123 ReadSnapshotId,
7124 }
7125 impl<'de> serde::Deserialize<'de> for GeneratedField {
7126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7127 where
7128 D: serde::Deserializer<'de>,
7129 {
7130 struct GeneratedVisitor;
7131
7132 impl serde::de::Visitor<'_> for GeneratedVisitor {
7133 type Value = GeneratedField;
7134
7135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7136 write!(formatter, "expected one of: {:?}", &FIELDS)
7137 }
7138
7139 #[allow(unused_variables)]
7140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7141 where
7142 E: serde::de::Error,
7143 {
7144 match value {
7145 "outputDataFilePaths" | "output_data_file_paths" => Ok(GeneratedField::OutputDataFilePaths),
7146 "inputDataFilePaths" | "input_data_file_paths" => Ok(GeneratedField::InputDataFilePaths),
7147 "readSnapshotId" | "read_snapshot_id" => Ok(GeneratedField::ReadSnapshotId),
7148 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7149 }
7150 }
7151 }
7152 deserializer.deserialize_identifier(GeneratedVisitor)
7153 }
7154 }
7155 struct GeneratedVisitor;
7156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7157 type Value = iceberg_pk_index_compaction_context::ResolverTaskInput;
7158
7159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7160 formatter.write_str("struct stream_plan.IcebergPkIndexCompactionContext.ResolverTaskInput")
7161 }
7162
7163 fn visit_map<V>(self, mut map_: V) -> std::result::Result<iceberg_pk_index_compaction_context::ResolverTaskInput, V::Error>
7164 where
7165 V: serde::de::MapAccess<'de>,
7166 {
7167 let mut output_data_file_paths__ = None;
7168 let mut input_data_file_paths__ = None;
7169 let mut read_snapshot_id__ = None;
7170 while let Some(k) = map_.next_key()? {
7171 match k {
7172 GeneratedField::OutputDataFilePaths => {
7173 if output_data_file_paths__.is_some() {
7174 return Err(serde::de::Error::duplicate_field("outputDataFilePaths"));
7175 }
7176 output_data_file_paths__ = Some(map_.next_value()?);
7177 }
7178 GeneratedField::InputDataFilePaths => {
7179 if input_data_file_paths__.is_some() {
7180 return Err(serde::de::Error::duplicate_field("inputDataFilePaths"));
7181 }
7182 input_data_file_paths__ = Some(map_.next_value()?);
7183 }
7184 GeneratedField::ReadSnapshotId => {
7185 if read_snapshot_id__.is_some() {
7186 return Err(serde::de::Error::duplicate_field("readSnapshotId"));
7187 }
7188 read_snapshot_id__ =
7189 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7190 ;
7191 }
7192 }
7193 }
7194 Ok(iceberg_pk_index_compaction_context::ResolverTaskInput {
7195 output_data_file_paths: output_data_file_paths__.unwrap_or_default(),
7196 input_data_file_paths: input_data_file_paths__.unwrap_or_default(),
7197 read_snapshot_id: read_snapshot_id__.unwrap_or_default(),
7198 })
7199 }
7200 }
7201 deserializer.deserialize_struct("stream_plan.IcebergPkIndexCompactionContext.ResolverTaskInput", FIELDS, GeneratedVisitor)
7202 }
7203}
7204impl serde::Serialize for IcebergWithPkIndexPositionDeleteMergerNode {
7205 #[allow(deprecated)]
7206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7207 where
7208 S: serde::Serializer,
7209 {
7210 use serde::ser::SerializeStruct;
7211 let mut len = 0;
7212 if self.sink_desc.is_some() {
7213 len += 1;
7214 }
7215 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", len)?;
7216 if let Some(v) = self.sink_desc.as_ref() {
7217 struct_ser.serialize_field("sinkDesc", v)?;
7218 }
7219 struct_ser.end()
7220 }
7221}
7222impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexPositionDeleteMergerNode {
7223 #[allow(deprecated)]
7224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7225 where
7226 D: serde::Deserializer<'de>,
7227 {
7228 const FIELDS: &[&str] = &[
7229 "sink_desc",
7230 "sinkDesc",
7231 ];
7232
7233 #[allow(clippy::enum_variant_names)]
7234 enum GeneratedField {
7235 SinkDesc,
7236 }
7237 impl<'de> serde::Deserialize<'de> for GeneratedField {
7238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7239 where
7240 D: serde::Deserializer<'de>,
7241 {
7242 struct GeneratedVisitor;
7243
7244 impl serde::de::Visitor<'_> for GeneratedVisitor {
7245 type Value = GeneratedField;
7246
7247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7248 write!(formatter, "expected one of: {:?}", &FIELDS)
7249 }
7250
7251 #[allow(unused_variables)]
7252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7253 where
7254 E: serde::de::Error,
7255 {
7256 match value {
7257 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
7258 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7259 }
7260 }
7261 }
7262 deserializer.deserialize_identifier(GeneratedVisitor)
7263 }
7264 }
7265 struct GeneratedVisitor;
7266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7267 type Value = IcebergWithPkIndexPositionDeleteMergerNode;
7268
7269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7270 formatter.write_str("struct stream_plan.IcebergWithPkIndexPositionDeleteMergerNode")
7271 }
7272
7273 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexPositionDeleteMergerNode, V::Error>
7274 where
7275 V: serde::de::MapAccess<'de>,
7276 {
7277 let mut sink_desc__ = None;
7278 while let Some(k) = map_.next_key()? {
7279 match k {
7280 GeneratedField::SinkDesc => {
7281 if sink_desc__.is_some() {
7282 return Err(serde::de::Error::duplicate_field("sinkDesc"));
7283 }
7284 sink_desc__ = map_.next_value()?;
7285 }
7286 }
7287 }
7288 Ok(IcebergWithPkIndexPositionDeleteMergerNode {
7289 sink_desc: sink_desc__,
7290 })
7291 }
7292 }
7293 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", FIELDS, GeneratedVisitor)
7294 }
7295}
7296impl serde::Serialize for IcebergWithPkIndexWriterNode {
7297 #[allow(deprecated)]
7298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7299 where
7300 S: serde::Serializer,
7301 {
7302 use serde::ser::SerializeStruct;
7303 let mut len = 0;
7304 if self.sink_desc.is_some() {
7305 len += 1;
7306 }
7307 if self.pk_index_table.is_some() {
7308 len += 1;
7309 }
7310 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexWriterNode", len)?;
7311 if let Some(v) = self.sink_desc.as_ref() {
7312 struct_ser.serialize_field("sinkDesc", v)?;
7313 }
7314 if let Some(v) = self.pk_index_table.as_ref() {
7315 struct_ser.serialize_field("pkIndexTable", v)?;
7316 }
7317 struct_ser.end()
7318 }
7319}
7320impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexWriterNode {
7321 #[allow(deprecated)]
7322 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7323 where
7324 D: serde::Deserializer<'de>,
7325 {
7326 const FIELDS: &[&str] = &[
7327 "sink_desc",
7328 "sinkDesc",
7329 "pk_index_table",
7330 "pkIndexTable",
7331 ];
7332
7333 #[allow(clippy::enum_variant_names)]
7334 enum GeneratedField {
7335 SinkDesc,
7336 PkIndexTable,
7337 }
7338 impl<'de> serde::Deserialize<'de> for GeneratedField {
7339 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7340 where
7341 D: serde::Deserializer<'de>,
7342 {
7343 struct GeneratedVisitor;
7344
7345 impl serde::de::Visitor<'_> for GeneratedVisitor {
7346 type Value = GeneratedField;
7347
7348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7349 write!(formatter, "expected one of: {:?}", &FIELDS)
7350 }
7351
7352 #[allow(unused_variables)]
7353 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7354 where
7355 E: serde::de::Error,
7356 {
7357 match value {
7358 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
7359 "pkIndexTable" | "pk_index_table" => Ok(GeneratedField::PkIndexTable),
7360 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7361 }
7362 }
7363 }
7364 deserializer.deserialize_identifier(GeneratedVisitor)
7365 }
7366 }
7367 struct GeneratedVisitor;
7368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7369 type Value = IcebergWithPkIndexWriterNode;
7370
7371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7372 formatter.write_str("struct stream_plan.IcebergWithPkIndexWriterNode")
7373 }
7374
7375 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexWriterNode, V::Error>
7376 where
7377 V: serde::de::MapAccess<'de>,
7378 {
7379 let mut sink_desc__ = None;
7380 let mut pk_index_table__ = None;
7381 while let Some(k) = map_.next_key()? {
7382 match k {
7383 GeneratedField::SinkDesc => {
7384 if sink_desc__.is_some() {
7385 return Err(serde::de::Error::duplicate_field("sinkDesc"));
7386 }
7387 sink_desc__ = map_.next_value()?;
7388 }
7389 GeneratedField::PkIndexTable => {
7390 if pk_index_table__.is_some() {
7391 return Err(serde::de::Error::duplicate_field("pkIndexTable"));
7392 }
7393 pk_index_table__ = map_.next_value()?;
7394 }
7395 }
7396 }
7397 Ok(IcebergWithPkIndexWriterNode {
7398 sink_desc: sink_desc__,
7399 pk_index_table: pk_index_table__,
7400 })
7401 }
7402 }
7403 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexWriterNode", FIELDS, GeneratedVisitor)
7404 }
7405}
7406impl serde::Serialize for InequalityPair {
7407 #[allow(deprecated)]
7408 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7409 where
7410 S: serde::Serializer,
7411 {
7412 use serde::ser::SerializeStruct;
7413 let mut len = 0;
7414 if self.key_required_larger != 0 {
7415 len += 1;
7416 }
7417 if self.key_required_smaller != 0 {
7418 len += 1;
7419 }
7420 if self.clean_state {
7421 len += 1;
7422 }
7423 if self.delta_expression.is_some() {
7424 len += 1;
7425 }
7426 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
7427 if self.key_required_larger != 0 {
7428 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
7429 }
7430 if self.key_required_smaller != 0 {
7431 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
7432 }
7433 if self.clean_state {
7434 struct_ser.serialize_field("cleanState", &self.clean_state)?;
7435 }
7436 if let Some(v) = self.delta_expression.as_ref() {
7437 struct_ser.serialize_field("deltaExpression", v)?;
7438 }
7439 struct_ser.end()
7440 }
7441}
7442impl<'de> serde::Deserialize<'de> for InequalityPair {
7443 #[allow(deprecated)]
7444 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7445 where
7446 D: serde::Deserializer<'de>,
7447 {
7448 const FIELDS: &[&str] = &[
7449 "key_required_larger",
7450 "keyRequiredLarger",
7451 "key_required_smaller",
7452 "keyRequiredSmaller",
7453 "clean_state",
7454 "cleanState",
7455 "delta_expression",
7456 "deltaExpression",
7457 ];
7458
7459 #[allow(clippy::enum_variant_names)]
7460 enum GeneratedField {
7461 KeyRequiredLarger,
7462 KeyRequiredSmaller,
7463 CleanState,
7464 DeltaExpression,
7465 }
7466 impl<'de> serde::Deserialize<'de> for GeneratedField {
7467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7468 where
7469 D: serde::Deserializer<'de>,
7470 {
7471 struct GeneratedVisitor;
7472
7473 impl serde::de::Visitor<'_> for GeneratedVisitor {
7474 type Value = GeneratedField;
7475
7476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7477 write!(formatter, "expected one of: {:?}", &FIELDS)
7478 }
7479
7480 #[allow(unused_variables)]
7481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7482 where
7483 E: serde::de::Error,
7484 {
7485 match value {
7486 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
7487 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
7488 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
7489 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
7490 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7491 }
7492 }
7493 }
7494 deserializer.deserialize_identifier(GeneratedVisitor)
7495 }
7496 }
7497 struct GeneratedVisitor;
7498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7499 type Value = InequalityPair;
7500
7501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7502 formatter.write_str("struct stream_plan.InequalityPair")
7503 }
7504
7505 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
7506 where
7507 V: serde::de::MapAccess<'de>,
7508 {
7509 let mut key_required_larger__ = None;
7510 let mut key_required_smaller__ = None;
7511 let mut clean_state__ = None;
7512 let mut delta_expression__ = None;
7513 while let Some(k) = map_.next_key()? {
7514 match k {
7515 GeneratedField::KeyRequiredLarger => {
7516 if key_required_larger__.is_some() {
7517 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
7518 }
7519 key_required_larger__ =
7520 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7521 ;
7522 }
7523 GeneratedField::KeyRequiredSmaller => {
7524 if key_required_smaller__.is_some() {
7525 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
7526 }
7527 key_required_smaller__ =
7528 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7529 ;
7530 }
7531 GeneratedField::CleanState => {
7532 if clean_state__.is_some() {
7533 return Err(serde::de::Error::duplicate_field("cleanState"));
7534 }
7535 clean_state__ = Some(map_.next_value()?);
7536 }
7537 GeneratedField::DeltaExpression => {
7538 if delta_expression__.is_some() {
7539 return Err(serde::de::Error::duplicate_field("deltaExpression"));
7540 }
7541 delta_expression__ = map_.next_value()?;
7542 }
7543 }
7544 }
7545 Ok(InequalityPair {
7546 key_required_larger: key_required_larger__.unwrap_or_default(),
7547 key_required_smaller: key_required_smaller__.unwrap_or_default(),
7548 clean_state: clean_state__.unwrap_or_default(),
7549 delta_expression: delta_expression__,
7550 })
7551 }
7552 }
7553 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
7554 }
7555}
7556impl serde::Serialize for InequalityPairV2 {
7557 #[allow(deprecated)]
7558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7559 where
7560 S: serde::Serializer,
7561 {
7562 use serde::ser::SerializeStruct;
7563 let mut len = 0;
7564 if self.left_idx != 0 {
7565 len += 1;
7566 }
7567 if self.right_idx != 0 {
7568 len += 1;
7569 }
7570 if self.clean_left_state {
7571 len += 1;
7572 }
7573 if self.clean_right_state {
7574 len += 1;
7575 }
7576 if self.op != 0 {
7577 len += 1;
7578 }
7579 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
7580 if self.left_idx != 0 {
7581 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
7582 }
7583 if self.right_idx != 0 {
7584 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
7585 }
7586 if self.clean_left_state {
7587 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
7588 }
7589 if self.clean_right_state {
7590 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
7591 }
7592 if self.op != 0 {
7593 let v = InequalityType::try_from(self.op)
7594 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
7595 struct_ser.serialize_field("op", &v)?;
7596 }
7597 struct_ser.end()
7598 }
7599}
7600impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
7601 #[allow(deprecated)]
7602 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7603 where
7604 D: serde::Deserializer<'de>,
7605 {
7606 const FIELDS: &[&str] = &[
7607 "left_idx",
7608 "leftIdx",
7609 "right_idx",
7610 "rightIdx",
7611 "clean_left_state",
7612 "cleanLeftState",
7613 "clean_right_state",
7614 "cleanRightState",
7615 "op",
7616 ];
7617
7618 #[allow(clippy::enum_variant_names)]
7619 enum GeneratedField {
7620 LeftIdx,
7621 RightIdx,
7622 CleanLeftState,
7623 CleanRightState,
7624 Op,
7625 }
7626 impl<'de> serde::Deserialize<'de> for GeneratedField {
7627 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7628 where
7629 D: serde::Deserializer<'de>,
7630 {
7631 struct GeneratedVisitor;
7632
7633 impl serde::de::Visitor<'_> for GeneratedVisitor {
7634 type Value = GeneratedField;
7635
7636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7637 write!(formatter, "expected one of: {:?}", &FIELDS)
7638 }
7639
7640 #[allow(unused_variables)]
7641 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7642 where
7643 E: serde::de::Error,
7644 {
7645 match value {
7646 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
7647 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
7648 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
7649 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
7650 "op" => Ok(GeneratedField::Op),
7651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7652 }
7653 }
7654 }
7655 deserializer.deserialize_identifier(GeneratedVisitor)
7656 }
7657 }
7658 struct GeneratedVisitor;
7659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7660 type Value = InequalityPairV2;
7661
7662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7663 formatter.write_str("struct stream_plan.InequalityPairV2")
7664 }
7665
7666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
7667 where
7668 V: serde::de::MapAccess<'de>,
7669 {
7670 let mut left_idx__ = None;
7671 let mut right_idx__ = None;
7672 let mut clean_left_state__ = None;
7673 let mut clean_right_state__ = None;
7674 let mut op__ = None;
7675 while let Some(k) = map_.next_key()? {
7676 match k {
7677 GeneratedField::LeftIdx => {
7678 if left_idx__.is_some() {
7679 return Err(serde::de::Error::duplicate_field("leftIdx"));
7680 }
7681 left_idx__ =
7682 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7683 ;
7684 }
7685 GeneratedField::RightIdx => {
7686 if right_idx__.is_some() {
7687 return Err(serde::de::Error::duplicate_field("rightIdx"));
7688 }
7689 right_idx__ =
7690 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7691 ;
7692 }
7693 GeneratedField::CleanLeftState => {
7694 if clean_left_state__.is_some() {
7695 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
7696 }
7697 clean_left_state__ = Some(map_.next_value()?);
7698 }
7699 GeneratedField::CleanRightState => {
7700 if clean_right_state__.is_some() {
7701 return Err(serde::de::Error::duplicate_field("cleanRightState"));
7702 }
7703 clean_right_state__ = Some(map_.next_value()?);
7704 }
7705 GeneratedField::Op => {
7706 if op__.is_some() {
7707 return Err(serde::de::Error::duplicate_field("op"));
7708 }
7709 op__ = Some(map_.next_value::<InequalityType>()? as i32);
7710 }
7711 }
7712 }
7713 Ok(InequalityPairV2 {
7714 left_idx: left_idx__.unwrap_or_default(),
7715 right_idx: right_idx__.unwrap_or_default(),
7716 clean_left_state: clean_left_state__.unwrap_or_default(),
7717 clean_right_state: clean_right_state__.unwrap_or_default(),
7718 op: op__.unwrap_or_default(),
7719 })
7720 }
7721 }
7722 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
7723 }
7724}
7725impl serde::Serialize for InequalityType {
7726 #[allow(deprecated)]
7727 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7728 where
7729 S: serde::Serializer,
7730 {
7731 let variant = match self {
7732 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
7733 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
7734 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7735 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
7736 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7737 };
7738 serializer.serialize_str(variant)
7739 }
7740}
7741impl<'de> serde::Deserialize<'de> for InequalityType {
7742 #[allow(deprecated)]
7743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7744 where
7745 D: serde::Deserializer<'de>,
7746 {
7747 const FIELDS: &[&str] = &[
7748 "INEQUALITY_TYPE_UNSPECIFIED",
7749 "INEQUALITY_TYPE_LESS_THAN",
7750 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7751 "INEQUALITY_TYPE_GREATER_THAN",
7752 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7753 ];
7754
7755 struct GeneratedVisitor;
7756
7757 impl serde::de::Visitor<'_> for GeneratedVisitor {
7758 type Value = InequalityType;
7759
7760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7761 write!(formatter, "expected one of: {:?}", &FIELDS)
7762 }
7763
7764 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7765 where
7766 E: serde::de::Error,
7767 {
7768 i32::try_from(v)
7769 .ok()
7770 .and_then(|x| x.try_into().ok())
7771 .ok_or_else(|| {
7772 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7773 })
7774 }
7775
7776 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7777 where
7778 E: serde::de::Error,
7779 {
7780 i32::try_from(v)
7781 .ok()
7782 .and_then(|x| x.try_into().ok())
7783 .ok_or_else(|| {
7784 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7785 })
7786 }
7787
7788 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7789 where
7790 E: serde::de::Error,
7791 {
7792 match value {
7793 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
7794 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
7795 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
7796 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
7797 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
7798 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7799 }
7800 }
7801 }
7802 deserializer.deserialize_any(GeneratedVisitor)
7803 }
7804}
7805impl serde::Serialize for InjectSourceOffsetsMutation {
7806 #[allow(deprecated)]
7807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7808 where
7809 S: serde::Serializer,
7810 {
7811 use serde::ser::SerializeStruct;
7812 let mut len = 0;
7813 if self.source_id != 0 {
7814 len += 1;
7815 }
7816 if !self.split_offsets.is_empty() {
7817 len += 1;
7818 }
7819 let mut struct_ser = serializer.serialize_struct("stream_plan.InjectSourceOffsetsMutation", len)?;
7820 if self.source_id != 0 {
7821 struct_ser.serialize_field("sourceId", &self.source_id)?;
7822 }
7823 if !self.split_offsets.is_empty() {
7824 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
7825 }
7826 struct_ser.end()
7827 }
7828}
7829impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsMutation {
7830 #[allow(deprecated)]
7831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7832 where
7833 D: serde::Deserializer<'de>,
7834 {
7835 const FIELDS: &[&str] = &[
7836 "source_id",
7837 "sourceId",
7838 "split_offsets",
7839 "splitOffsets",
7840 ];
7841
7842 #[allow(clippy::enum_variant_names)]
7843 enum GeneratedField {
7844 SourceId,
7845 SplitOffsets,
7846 }
7847 impl<'de> serde::Deserialize<'de> for GeneratedField {
7848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7849 where
7850 D: serde::Deserializer<'de>,
7851 {
7852 struct GeneratedVisitor;
7853
7854 impl serde::de::Visitor<'_> for GeneratedVisitor {
7855 type Value = GeneratedField;
7856
7857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7858 write!(formatter, "expected one of: {:?}", &FIELDS)
7859 }
7860
7861 #[allow(unused_variables)]
7862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7863 where
7864 E: serde::de::Error,
7865 {
7866 match value {
7867 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7868 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
7869 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7870 }
7871 }
7872 }
7873 deserializer.deserialize_identifier(GeneratedVisitor)
7874 }
7875 }
7876 struct GeneratedVisitor;
7877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7878 type Value = InjectSourceOffsetsMutation;
7879
7880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7881 formatter.write_str("struct stream_plan.InjectSourceOffsetsMutation")
7882 }
7883
7884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsMutation, V::Error>
7885 where
7886 V: serde::de::MapAccess<'de>,
7887 {
7888 let mut source_id__ = None;
7889 let mut split_offsets__ = None;
7890 while let Some(k) = map_.next_key()? {
7891 match k {
7892 GeneratedField::SourceId => {
7893 if source_id__.is_some() {
7894 return Err(serde::de::Error::duplicate_field("sourceId"));
7895 }
7896 source_id__ =
7897 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7898 ;
7899 }
7900 GeneratedField::SplitOffsets => {
7901 if split_offsets__.is_some() {
7902 return Err(serde::de::Error::duplicate_field("splitOffsets"));
7903 }
7904 split_offsets__ = Some(
7905 map_.next_value::<std::collections::HashMap<_, _>>()?
7906 );
7907 }
7908 }
7909 }
7910 Ok(InjectSourceOffsetsMutation {
7911 source_id: source_id__.unwrap_or_default(),
7912 split_offsets: split_offsets__.unwrap_or_default(),
7913 })
7914 }
7915 }
7916 deserializer.deserialize_struct("stream_plan.InjectSourceOffsetsMutation", FIELDS, GeneratedVisitor)
7917 }
7918}
7919impl serde::Serialize for JoinEncodingType {
7920 #[allow(deprecated)]
7921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7922 where
7923 S: serde::Serializer,
7924 {
7925 let variant = match self {
7926 Self::Unspecified => "UNSPECIFIED",
7927 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
7928 Self::CpuOptimized => "CPU_OPTIMIZED",
7929 };
7930 serializer.serialize_str(variant)
7931 }
7932}
7933impl<'de> serde::Deserialize<'de> for JoinEncodingType {
7934 #[allow(deprecated)]
7935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7936 where
7937 D: serde::Deserializer<'de>,
7938 {
7939 const FIELDS: &[&str] = &[
7940 "UNSPECIFIED",
7941 "MEMORY_OPTIMIZED",
7942 "CPU_OPTIMIZED",
7943 ];
7944
7945 struct GeneratedVisitor;
7946
7947 impl serde::de::Visitor<'_> for GeneratedVisitor {
7948 type Value = JoinEncodingType;
7949
7950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7951 write!(formatter, "expected one of: {:?}", &FIELDS)
7952 }
7953
7954 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7955 where
7956 E: serde::de::Error,
7957 {
7958 i32::try_from(v)
7959 .ok()
7960 .and_then(|x| x.try_into().ok())
7961 .ok_or_else(|| {
7962 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7963 })
7964 }
7965
7966 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7967 where
7968 E: serde::de::Error,
7969 {
7970 i32::try_from(v)
7971 .ok()
7972 .and_then(|x| x.try_into().ok())
7973 .ok_or_else(|| {
7974 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7975 })
7976 }
7977
7978 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7979 where
7980 E: serde::de::Error,
7981 {
7982 match value {
7983 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
7984 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
7985 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
7986 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7987 }
7988 }
7989 }
7990 deserializer.deserialize_any(GeneratedVisitor)
7991 }
7992}
7993impl serde::Serialize for JoinKeyWatermarkIndex {
7994 #[allow(deprecated)]
7995 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7996 where
7997 S: serde::Serializer,
7998 {
7999 use serde::ser::SerializeStruct;
8000 let mut len = 0;
8001 if self.index != 0 {
8002 len += 1;
8003 }
8004 if self.do_state_cleaning {
8005 len += 1;
8006 }
8007 let mut struct_ser = serializer.serialize_struct("stream_plan.JoinKeyWatermarkIndex", len)?;
8008 if self.index != 0 {
8009 struct_ser.serialize_field("index", &self.index)?;
8010 }
8011 if self.do_state_cleaning {
8012 struct_ser.serialize_field("doStateCleaning", &self.do_state_cleaning)?;
8013 }
8014 struct_ser.end()
8015 }
8016}
8017impl<'de> serde::Deserialize<'de> for JoinKeyWatermarkIndex {
8018 #[allow(deprecated)]
8019 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8020 where
8021 D: serde::Deserializer<'de>,
8022 {
8023 const FIELDS: &[&str] = &[
8024 "index",
8025 "do_state_cleaning",
8026 "doStateCleaning",
8027 ];
8028
8029 #[allow(clippy::enum_variant_names)]
8030 enum GeneratedField {
8031 Index,
8032 DoStateCleaning,
8033 }
8034 impl<'de> serde::Deserialize<'de> for GeneratedField {
8035 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8036 where
8037 D: serde::Deserializer<'de>,
8038 {
8039 struct GeneratedVisitor;
8040
8041 impl serde::de::Visitor<'_> for GeneratedVisitor {
8042 type Value = GeneratedField;
8043
8044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8045 write!(formatter, "expected one of: {:?}", &FIELDS)
8046 }
8047
8048 #[allow(unused_variables)]
8049 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8050 where
8051 E: serde::de::Error,
8052 {
8053 match value {
8054 "index" => Ok(GeneratedField::Index),
8055 "doStateCleaning" | "do_state_cleaning" => Ok(GeneratedField::DoStateCleaning),
8056 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8057 }
8058 }
8059 }
8060 deserializer.deserialize_identifier(GeneratedVisitor)
8061 }
8062 }
8063 struct GeneratedVisitor;
8064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8065 type Value = JoinKeyWatermarkIndex;
8066
8067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8068 formatter.write_str("struct stream_plan.JoinKeyWatermarkIndex")
8069 }
8070
8071 fn visit_map<V>(self, mut map_: V) -> std::result::Result<JoinKeyWatermarkIndex, V::Error>
8072 where
8073 V: serde::de::MapAccess<'de>,
8074 {
8075 let mut index__ = None;
8076 let mut do_state_cleaning__ = None;
8077 while let Some(k) = map_.next_key()? {
8078 match k {
8079 GeneratedField::Index => {
8080 if index__.is_some() {
8081 return Err(serde::de::Error::duplicate_field("index"));
8082 }
8083 index__ =
8084 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8085 ;
8086 }
8087 GeneratedField::DoStateCleaning => {
8088 if do_state_cleaning__.is_some() {
8089 return Err(serde::de::Error::duplicate_field("doStateCleaning"));
8090 }
8091 do_state_cleaning__ = Some(map_.next_value()?);
8092 }
8093 }
8094 }
8095 Ok(JoinKeyWatermarkIndex {
8096 index: index__.unwrap_or_default(),
8097 do_state_cleaning: do_state_cleaning__.unwrap_or_default(),
8098 })
8099 }
8100 }
8101 deserializer.deserialize_struct("stream_plan.JoinKeyWatermarkIndex", FIELDS, GeneratedVisitor)
8102 }
8103}
8104impl serde::Serialize for ListFinishMutation {
8105 #[allow(deprecated)]
8106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8107 where
8108 S: serde::Serializer,
8109 {
8110 use serde::ser::SerializeStruct;
8111 let mut len = 0;
8112 if self.associated_source_id != 0 {
8113 len += 1;
8114 }
8115 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
8116 if self.associated_source_id != 0 {
8117 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8118 }
8119 struct_ser.end()
8120 }
8121}
8122impl<'de> serde::Deserialize<'de> for ListFinishMutation {
8123 #[allow(deprecated)]
8124 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8125 where
8126 D: serde::Deserializer<'de>,
8127 {
8128 const FIELDS: &[&str] = &[
8129 "associated_source_id",
8130 "associatedSourceId",
8131 ];
8132
8133 #[allow(clippy::enum_variant_names)]
8134 enum GeneratedField {
8135 AssociatedSourceId,
8136 }
8137 impl<'de> serde::Deserialize<'de> for GeneratedField {
8138 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8139 where
8140 D: serde::Deserializer<'de>,
8141 {
8142 struct GeneratedVisitor;
8143
8144 impl serde::de::Visitor<'_> for GeneratedVisitor {
8145 type Value = GeneratedField;
8146
8147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8148 write!(formatter, "expected one of: {:?}", &FIELDS)
8149 }
8150
8151 #[allow(unused_variables)]
8152 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8153 where
8154 E: serde::de::Error,
8155 {
8156 match value {
8157 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8158 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8159 }
8160 }
8161 }
8162 deserializer.deserialize_identifier(GeneratedVisitor)
8163 }
8164 }
8165 struct GeneratedVisitor;
8166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8167 type Value = ListFinishMutation;
8168
8169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8170 formatter.write_str("struct stream_plan.ListFinishMutation")
8171 }
8172
8173 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
8174 where
8175 V: serde::de::MapAccess<'de>,
8176 {
8177 let mut associated_source_id__ = None;
8178 while let Some(k) = map_.next_key()? {
8179 match k {
8180 GeneratedField::AssociatedSourceId => {
8181 if associated_source_id__.is_some() {
8182 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8183 }
8184 associated_source_id__ =
8185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8186 ;
8187 }
8188 }
8189 }
8190 Ok(ListFinishMutation {
8191 associated_source_id: associated_source_id__.unwrap_or_default(),
8192 })
8193 }
8194 }
8195 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
8196 }
8197}
8198impl serde::Serialize for LoadFinishMutation {
8199 #[allow(deprecated)]
8200 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8201 where
8202 S: serde::Serializer,
8203 {
8204 use serde::ser::SerializeStruct;
8205 let mut len = 0;
8206 if self.associated_source_id != 0 {
8207 len += 1;
8208 }
8209 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
8210 if self.associated_source_id != 0 {
8211 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8212 }
8213 struct_ser.end()
8214 }
8215}
8216impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
8217 #[allow(deprecated)]
8218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8219 where
8220 D: serde::Deserializer<'de>,
8221 {
8222 const FIELDS: &[&str] = &[
8223 "associated_source_id",
8224 "associatedSourceId",
8225 ];
8226
8227 #[allow(clippy::enum_variant_names)]
8228 enum GeneratedField {
8229 AssociatedSourceId,
8230 }
8231 impl<'de> serde::Deserialize<'de> for GeneratedField {
8232 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8233 where
8234 D: serde::Deserializer<'de>,
8235 {
8236 struct GeneratedVisitor;
8237
8238 impl serde::de::Visitor<'_> for GeneratedVisitor {
8239 type Value = GeneratedField;
8240
8241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8242 write!(formatter, "expected one of: {:?}", &FIELDS)
8243 }
8244
8245 #[allow(unused_variables)]
8246 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8247 where
8248 E: serde::de::Error,
8249 {
8250 match value {
8251 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8252 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8253 }
8254 }
8255 }
8256 deserializer.deserialize_identifier(GeneratedVisitor)
8257 }
8258 }
8259 struct GeneratedVisitor;
8260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8261 type Value = LoadFinishMutation;
8262
8263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8264 formatter.write_str("struct stream_plan.LoadFinishMutation")
8265 }
8266
8267 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
8268 where
8269 V: serde::de::MapAccess<'de>,
8270 {
8271 let mut associated_source_id__ = None;
8272 while let Some(k) = map_.next_key()? {
8273 match k {
8274 GeneratedField::AssociatedSourceId => {
8275 if associated_source_id__.is_some() {
8276 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8277 }
8278 associated_source_id__ =
8279 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8280 ;
8281 }
8282 }
8283 }
8284 Ok(LoadFinishMutation {
8285 associated_source_id: associated_source_id__.unwrap_or_default(),
8286 })
8287 }
8288 }
8289 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
8290 }
8291}
8292impl serde::Serialize for LocalApproxPercentileNode {
8293 #[allow(deprecated)]
8294 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8295 where
8296 S: serde::Serializer,
8297 {
8298 use serde::ser::SerializeStruct;
8299 let mut len = 0;
8300 if self.base != 0. {
8301 len += 1;
8302 }
8303 if self.percentile_index != 0 {
8304 len += 1;
8305 }
8306 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
8307 if self.base != 0. {
8308 struct_ser.serialize_field("base", &self.base)?;
8309 }
8310 if self.percentile_index != 0 {
8311 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
8312 }
8313 struct_ser.end()
8314 }
8315}
8316impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
8317 #[allow(deprecated)]
8318 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8319 where
8320 D: serde::Deserializer<'de>,
8321 {
8322 const FIELDS: &[&str] = &[
8323 "base",
8324 "percentile_index",
8325 "percentileIndex",
8326 ];
8327
8328 #[allow(clippy::enum_variant_names)]
8329 enum GeneratedField {
8330 Base,
8331 PercentileIndex,
8332 }
8333 impl<'de> serde::Deserialize<'de> for GeneratedField {
8334 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8335 where
8336 D: serde::Deserializer<'de>,
8337 {
8338 struct GeneratedVisitor;
8339
8340 impl serde::de::Visitor<'_> for GeneratedVisitor {
8341 type Value = GeneratedField;
8342
8343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8344 write!(formatter, "expected one of: {:?}", &FIELDS)
8345 }
8346
8347 #[allow(unused_variables)]
8348 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8349 where
8350 E: serde::de::Error,
8351 {
8352 match value {
8353 "base" => Ok(GeneratedField::Base),
8354 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
8355 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8356 }
8357 }
8358 }
8359 deserializer.deserialize_identifier(GeneratedVisitor)
8360 }
8361 }
8362 struct GeneratedVisitor;
8363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8364 type Value = LocalApproxPercentileNode;
8365
8366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8367 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
8368 }
8369
8370 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
8371 where
8372 V: serde::de::MapAccess<'de>,
8373 {
8374 let mut base__ = None;
8375 let mut percentile_index__ = None;
8376 while let Some(k) = map_.next_key()? {
8377 match k {
8378 GeneratedField::Base => {
8379 if base__.is_some() {
8380 return Err(serde::de::Error::duplicate_field("base"));
8381 }
8382 base__ =
8383 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8384 ;
8385 }
8386 GeneratedField::PercentileIndex => {
8387 if percentile_index__.is_some() {
8388 return Err(serde::de::Error::duplicate_field("percentileIndex"));
8389 }
8390 percentile_index__ =
8391 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8392 ;
8393 }
8394 }
8395 }
8396 Ok(LocalApproxPercentileNode {
8397 base: base__.unwrap_or_default(),
8398 percentile_index: percentile_index__.unwrap_or_default(),
8399 })
8400 }
8401 }
8402 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
8403 }
8404}
8405impl serde::Serialize for LocalityProviderNode {
8406 #[allow(deprecated)]
8407 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8408 where
8409 S: serde::Serializer,
8410 {
8411 use serde::ser::SerializeStruct;
8412 let mut len = 0;
8413 if !self.locality_columns.is_empty() {
8414 len += 1;
8415 }
8416 if self.state_table.is_some() {
8417 len += 1;
8418 }
8419 if self.progress_table.is_some() {
8420 len += 1;
8421 }
8422 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
8423 if !self.locality_columns.is_empty() {
8424 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
8425 }
8426 if let Some(v) = self.state_table.as_ref() {
8427 struct_ser.serialize_field("stateTable", v)?;
8428 }
8429 if let Some(v) = self.progress_table.as_ref() {
8430 struct_ser.serialize_field("progressTable", v)?;
8431 }
8432 struct_ser.end()
8433 }
8434}
8435impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
8436 #[allow(deprecated)]
8437 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8438 where
8439 D: serde::Deserializer<'de>,
8440 {
8441 const FIELDS: &[&str] = &[
8442 "locality_columns",
8443 "localityColumns",
8444 "state_table",
8445 "stateTable",
8446 "progress_table",
8447 "progressTable",
8448 ];
8449
8450 #[allow(clippy::enum_variant_names)]
8451 enum GeneratedField {
8452 LocalityColumns,
8453 StateTable,
8454 ProgressTable,
8455 }
8456 impl<'de> serde::Deserialize<'de> for GeneratedField {
8457 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8458 where
8459 D: serde::Deserializer<'de>,
8460 {
8461 struct GeneratedVisitor;
8462
8463 impl serde::de::Visitor<'_> for GeneratedVisitor {
8464 type Value = GeneratedField;
8465
8466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8467 write!(formatter, "expected one of: {:?}", &FIELDS)
8468 }
8469
8470 #[allow(unused_variables)]
8471 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8472 where
8473 E: serde::de::Error,
8474 {
8475 match value {
8476 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
8477 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8478 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
8479 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8480 }
8481 }
8482 }
8483 deserializer.deserialize_identifier(GeneratedVisitor)
8484 }
8485 }
8486 struct GeneratedVisitor;
8487 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8488 type Value = LocalityProviderNode;
8489
8490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8491 formatter.write_str("struct stream_plan.LocalityProviderNode")
8492 }
8493
8494 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
8495 where
8496 V: serde::de::MapAccess<'de>,
8497 {
8498 let mut locality_columns__ = None;
8499 let mut state_table__ = None;
8500 let mut progress_table__ = None;
8501 while let Some(k) = map_.next_key()? {
8502 match k {
8503 GeneratedField::LocalityColumns => {
8504 if locality_columns__.is_some() {
8505 return Err(serde::de::Error::duplicate_field("localityColumns"));
8506 }
8507 locality_columns__ =
8508 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8509 .into_iter().map(|x| x.0).collect())
8510 ;
8511 }
8512 GeneratedField::StateTable => {
8513 if state_table__.is_some() {
8514 return Err(serde::de::Error::duplicate_field("stateTable"));
8515 }
8516 state_table__ = map_.next_value()?;
8517 }
8518 GeneratedField::ProgressTable => {
8519 if progress_table__.is_some() {
8520 return Err(serde::de::Error::duplicate_field("progressTable"));
8521 }
8522 progress_table__ = map_.next_value()?;
8523 }
8524 }
8525 }
8526 Ok(LocalityProviderNode {
8527 locality_columns: locality_columns__.unwrap_or_default(),
8528 state_table: state_table__,
8529 progress_table: progress_table__,
8530 })
8531 }
8532 }
8533 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
8534 }
8535}
8536impl serde::Serialize for LookupNode {
8537 #[allow(deprecated)]
8538 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8539 where
8540 S: serde::Serializer,
8541 {
8542 use serde::ser::SerializeStruct;
8543 let mut len = 0;
8544 if !self.arrange_key.is_empty() {
8545 len += 1;
8546 }
8547 if !self.stream_key.is_empty() {
8548 len += 1;
8549 }
8550 if self.use_current_epoch {
8551 len += 1;
8552 }
8553 if !self.column_mapping.is_empty() {
8554 len += 1;
8555 }
8556 if self.arrangement_table_info.is_some() {
8557 len += 1;
8558 }
8559 if self.arrangement_table_id.is_some() {
8560 len += 1;
8561 }
8562 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
8563 if !self.arrange_key.is_empty() {
8564 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
8565 }
8566 if !self.stream_key.is_empty() {
8567 struct_ser.serialize_field("streamKey", &self.stream_key)?;
8568 }
8569 if self.use_current_epoch {
8570 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
8571 }
8572 if !self.column_mapping.is_empty() {
8573 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
8574 }
8575 if let Some(v) = self.arrangement_table_info.as_ref() {
8576 struct_ser.serialize_field("arrangementTableInfo", v)?;
8577 }
8578 if let Some(v) = self.arrangement_table_id.as_ref() {
8579 match v {
8580 lookup_node::ArrangementTableId::TableId(v) => {
8581 struct_ser.serialize_field("tableId", v)?;
8582 }
8583 lookup_node::ArrangementTableId::IndexId(v) => {
8584 struct_ser.serialize_field("indexId", v)?;
8585 }
8586 }
8587 }
8588 struct_ser.end()
8589 }
8590}
8591impl<'de> serde::Deserialize<'de> for LookupNode {
8592 #[allow(deprecated)]
8593 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8594 where
8595 D: serde::Deserializer<'de>,
8596 {
8597 const FIELDS: &[&str] = &[
8598 "arrange_key",
8599 "arrangeKey",
8600 "stream_key",
8601 "streamKey",
8602 "use_current_epoch",
8603 "useCurrentEpoch",
8604 "column_mapping",
8605 "columnMapping",
8606 "arrangement_table_info",
8607 "arrangementTableInfo",
8608 "table_id",
8609 "tableId",
8610 "index_id",
8611 "indexId",
8612 ];
8613
8614 #[allow(clippy::enum_variant_names)]
8615 enum GeneratedField {
8616 ArrangeKey,
8617 StreamKey,
8618 UseCurrentEpoch,
8619 ColumnMapping,
8620 ArrangementTableInfo,
8621 TableId,
8622 IndexId,
8623 }
8624 impl<'de> serde::Deserialize<'de> for GeneratedField {
8625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8626 where
8627 D: serde::Deserializer<'de>,
8628 {
8629 struct GeneratedVisitor;
8630
8631 impl serde::de::Visitor<'_> for GeneratedVisitor {
8632 type Value = GeneratedField;
8633
8634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8635 write!(formatter, "expected one of: {:?}", &FIELDS)
8636 }
8637
8638 #[allow(unused_variables)]
8639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8640 where
8641 E: serde::de::Error,
8642 {
8643 match value {
8644 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
8645 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
8646 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
8647 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
8648 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
8649 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8650 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8652 }
8653 }
8654 }
8655 deserializer.deserialize_identifier(GeneratedVisitor)
8656 }
8657 }
8658 struct GeneratedVisitor;
8659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8660 type Value = LookupNode;
8661
8662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8663 formatter.write_str("struct stream_plan.LookupNode")
8664 }
8665
8666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
8667 where
8668 V: serde::de::MapAccess<'de>,
8669 {
8670 let mut arrange_key__ = None;
8671 let mut stream_key__ = None;
8672 let mut use_current_epoch__ = None;
8673 let mut column_mapping__ = None;
8674 let mut arrangement_table_info__ = None;
8675 let mut arrangement_table_id__ = None;
8676 while let Some(k) = map_.next_key()? {
8677 match k {
8678 GeneratedField::ArrangeKey => {
8679 if arrange_key__.is_some() {
8680 return Err(serde::de::Error::duplicate_field("arrangeKey"));
8681 }
8682 arrange_key__ =
8683 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8684 .into_iter().map(|x| x.0).collect())
8685 ;
8686 }
8687 GeneratedField::StreamKey => {
8688 if stream_key__.is_some() {
8689 return Err(serde::de::Error::duplicate_field("streamKey"));
8690 }
8691 stream_key__ =
8692 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8693 .into_iter().map(|x| x.0).collect())
8694 ;
8695 }
8696 GeneratedField::UseCurrentEpoch => {
8697 if use_current_epoch__.is_some() {
8698 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
8699 }
8700 use_current_epoch__ = Some(map_.next_value()?);
8701 }
8702 GeneratedField::ColumnMapping => {
8703 if column_mapping__.is_some() {
8704 return Err(serde::de::Error::duplicate_field("columnMapping"));
8705 }
8706 column_mapping__ =
8707 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8708 .into_iter().map(|x| x.0).collect())
8709 ;
8710 }
8711 GeneratedField::ArrangementTableInfo => {
8712 if arrangement_table_info__.is_some() {
8713 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
8714 }
8715 arrangement_table_info__ = map_.next_value()?;
8716 }
8717 GeneratedField::TableId => {
8718 if arrangement_table_id__.is_some() {
8719 return Err(serde::de::Error::duplicate_field("tableId"));
8720 }
8721 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
8722 }
8723 GeneratedField::IndexId => {
8724 if arrangement_table_id__.is_some() {
8725 return Err(serde::de::Error::duplicate_field("indexId"));
8726 }
8727 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
8728 }
8729 }
8730 }
8731 Ok(LookupNode {
8732 arrange_key: arrange_key__.unwrap_or_default(),
8733 stream_key: stream_key__.unwrap_or_default(),
8734 use_current_epoch: use_current_epoch__.unwrap_or_default(),
8735 column_mapping: column_mapping__.unwrap_or_default(),
8736 arrangement_table_info: arrangement_table_info__,
8737 arrangement_table_id: arrangement_table_id__,
8738 })
8739 }
8740 }
8741 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
8742 }
8743}
8744impl serde::Serialize for LookupUnionNode {
8745 #[allow(deprecated)]
8746 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8747 where
8748 S: serde::Serializer,
8749 {
8750 use serde::ser::SerializeStruct;
8751 let mut len = 0;
8752 if !self.order.is_empty() {
8753 len += 1;
8754 }
8755 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
8756 if !self.order.is_empty() {
8757 struct_ser.serialize_field("order", &self.order)?;
8758 }
8759 struct_ser.end()
8760 }
8761}
8762impl<'de> serde::Deserialize<'de> for LookupUnionNode {
8763 #[allow(deprecated)]
8764 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8765 where
8766 D: serde::Deserializer<'de>,
8767 {
8768 const FIELDS: &[&str] = &[
8769 "order",
8770 ];
8771
8772 #[allow(clippy::enum_variant_names)]
8773 enum GeneratedField {
8774 Order,
8775 }
8776 impl<'de> serde::Deserialize<'de> for GeneratedField {
8777 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8778 where
8779 D: serde::Deserializer<'de>,
8780 {
8781 struct GeneratedVisitor;
8782
8783 impl serde::de::Visitor<'_> for GeneratedVisitor {
8784 type Value = GeneratedField;
8785
8786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8787 write!(formatter, "expected one of: {:?}", &FIELDS)
8788 }
8789
8790 #[allow(unused_variables)]
8791 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8792 where
8793 E: serde::de::Error,
8794 {
8795 match value {
8796 "order" => Ok(GeneratedField::Order),
8797 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8798 }
8799 }
8800 }
8801 deserializer.deserialize_identifier(GeneratedVisitor)
8802 }
8803 }
8804 struct GeneratedVisitor;
8805 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8806 type Value = LookupUnionNode;
8807
8808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8809 formatter.write_str("struct stream_plan.LookupUnionNode")
8810 }
8811
8812 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
8813 where
8814 V: serde::de::MapAccess<'de>,
8815 {
8816 let mut order__ = None;
8817 while let Some(k) = map_.next_key()? {
8818 match k {
8819 GeneratedField::Order => {
8820 if order__.is_some() {
8821 return Err(serde::de::Error::duplicate_field("order"));
8822 }
8823 order__ =
8824 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8825 .into_iter().map(|x| x.0).collect())
8826 ;
8827 }
8828 }
8829 }
8830 Ok(LookupUnionNode {
8831 order: order__.unwrap_or_default(),
8832 })
8833 }
8834 }
8835 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
8836 }
8837}
8838impl serde::Serialize for MatchRecognizeAfterMatchSkip {
8839 #[allow(deprecated)]
8840 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8841 where
8842 S: serde::Serializer,
8843 {
8844 use serde::ser::SerializeStruct;
8845 let mut len = 0;
8846 if self.mode != 0 {
8847 len += 1;
8848 }
8849 if self.target.is_some() {
8850 len += 1;
8851 }
8852 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeAfterMatchSkip", len)?;
8853 if self.mode != 0 {
8854 let v = match_recognize_after_match_skip::Mode::try_from(self.mode)
8855 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?;
8856 struct_ser.serialize_field("mode", &v)?;
8857 }
8858 if let Some(v) = self.target.as_ref() {
8859 struct_ser.serialize_field("target", v)?;
8860 }
8861 struct_ser.end()
8862 }
8863}
8864impl<'de> serde::Deserialize<'de> for MatchRecognizeAfterMatchSkip {
8865 #[allow(deprecated)]
8866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8867 where
8868 D: serde::Deserializer<'de>,
8869 {
8870 const FIELDS: &[&str] = &[
8871 "mode",
8872 "target",
8873 ];
8874
8875 #[allow(clippy::enum_variant_names)]
8876 enum GeneratedField {
8877 Mode,
8878 Target,
8879 }
8880 impl<'de> serde::Deserialize<'de> for GeneratedField {
8881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8882 where
8883 D: serde::Deserializer<'de>,
8884 {
8885 struct GeneratedVisitor;
8886
8887 impl serde::de::Visitor<'_> for GeneratedVisitor {
8888 type Value = GeneratedField;
8889
8890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8891 write!(formatter, "expected one of: {:?}", &FIELDS)
8892 }
8893
8894 #[allow(unused_variables)]
8895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8896 where
8897 E: serde::de::Error,
8898 {
8899 match value {
8900 "mode" => Ok(GeneratedField::Mode),
8901 "target" => Ok(GeneratedField::Target),
8902 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8903 }
8904 }
8905 }
8906 deserializer.deserialize_identifier(GeneratedVisitor)
8907 }
8908 }
8909 struct GeneratedVisitor;
8910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8911 type Value = MatchRecognizeAfterMatchSkip;
8912
8913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8914 formatter.write_str("struct stream_plan.MatchRecognizeAfterMatchSkip")
8915 }
8916
8917 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeAfterMatchSkip, V::Error>
8918 where
8919 V: serde::de::MapAccess<'de>,
8920 {
8921 let mut mode__ = None;
8922 let mut target__ = None;
8923 while let Some(k) = map_.next_key()? {
8924 match k {
8925 GeneratedField::Mode => {
8926 if mode__.is_some() {
8927 return Err(serde::de::Error::duplicate_field("mode"));
8928 }
8929 mode__ = Some(map_.next_value::<match_recognize_after_match_skip::Mode>()? as i32);
8930 }
8931 GeneratedField::Target => {
8932 if target__.is_some() {
8933 return Err(serde::de::Error::duplicate_field("target"));
8934 }
8935 target__ = map_.next_value()?;
8936 }
8937 }
8938 }
8939 Ok(MatchRecognizeAfterMatchSkip {
8940 mode: mode__.unwrap_or_default(),
8941 target: target__,
8942 })
8943 }
8944 }
8945 deserializer.deserialize_struct("stream_plan.MatchRecognizeAfterMatchSkip", FIELDS, GeneratedVisitor)
8946 }
8947}
8948impl serde::Serialize for match_recognize_after_match_skip::Mode {
8949 #[allow(deprecated)]
8950 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8951 where
8952 S: serde::Serializer,
8953 {
8954 let variant = match self {
8955 Self::Unspecified => "MODE_UNSPECIFIED",
8956 Self::PastLastRow => "MODE_PAST_LAST_ROW",
8957 Self::ToNextRow => "MODE_TO_NEXT_ROW",
8958 Self::ToFirst => "MODE_TO_FIRST",
8959 Self::ToLast => "MODE_TO_LAST",
8960 };
8961 serializer.serialize_str(variant)
8962 }
8963}
8964impl<'de> serde::Deserialize<'de> for match_recognize_after_match_skip::Mode {
8965 #[allow(deprecated)]
8966 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8967 where
8968 D: serde::Deserializer<'de>,
8969 {
8970 const FIELDS: &[&str] = &[
8971 "MODE_UNSPECIFIED",
8972 "MODE_PAST_LAST_ROW",
8973 "MODE_TO_NEXT_ROW",
8974 "MODE_TO_FIRST",
8975 "MODE_TO_LAST",
8976 ];
8977
8978 struct GeneratedVisitor;
8979
8980 impl serde::de::Visitor<'_> for GeneratedVisitor {
8981 type Value = match_recognize_after_match_skip::Mode;
8982
8983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8984 write!(formatter, "expected one of: {:?}", &FIELDS)
8985 }
8986
8987 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8988 where
8989 E: serde::de::Error,
8990 {
8991 i32::try_from(v)
8992 .ok()
8993 .and_then(|x| x.try_into().ok())
8994 .ok_or_else(|| {
8995 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8996 })
8997 }
8998
8999 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9000 where
9001 E: serde::de::Error,
9002 {
9003 i32::try_from(v)
9004 .ok()
9005 .and_then(|x| x.try_into().ok())
9006 .ok_or_else(|| {
9007 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9008 })
9009 }
9010
9011 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9012 where
9013 E: serde::de::Error,
9014 {
9015 match value {
9016 "MODE_UNSPECIFIED" => Ok(match_recognize_after_match_skip::Mode::Unspecified),
9017 "MODE_PAST_LAST_ROW" => Ok(match_recognize_after_match_skip::Mode::PastLastRow),
9018 "MODE_TO_NEXT_ROW" => Ok(match_recognize_after_match_skip::Mode::ToNextRow),
9019 "MODE_TO_FIRST" => Ok(match_recognize_after_match_skip::Mode::ToFirst),
9020 "MODE_TO_LAST" => Ok(match_recognize_after_match_skip::Mode::ToLast),
9021 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9022 }
9023 }
9024 }
9025 deserializer.deserialize_any(GeneratedVisitor)
9026 }
9027}
9028impl serde::Serialize for MatchRecognizeDefine {
9029 #[allow(deprecated)]
9030 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9031 where
9032 S: serde::Serializer,
9033 {
9034 use serde::ser::SerializeStruct;
9035 let mut len = 0;
9036 if !self.symbol.is_empty() {
9037 len += 1;
9038 }
9039 if self.condition.is_some() {
9040 len += 1;
9041 }
9042 if !self.slots.is_empty() {
9043 len += 1;
9044 }
9045 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeDefine", len)?;
9046 if !self.symbol.is_empty() {
9047 struct_ser.serialize_field("symbol", &self.symbol)?;
9048 }
9049 if let Some(v) = self.condition.as_ref() {
9050 struct_ser.serialize_field("condition", v)?;
9051 }
9052 if !self.slots.is_empty() {
9053 struct_ser.serialize_field("slots", &self.slots)?;
9054 }
9055 struct_ser.end()
9056 }
9057}
9058impl<'de> serde::Deserialize<'de> for MatchRecognizeDefine {
9059 #[allow(deprecated)]
9060 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9061 where
9062 D: serde::Deserializer<'de>,
9063 {
9064 const FIELDS: &[&str] = &[
9065 "symbol",
9066 "condition",
9067 "slots",
9068 ];
9069
9070 #[allow(clippy::enum_variant_names)]
9071 enum GeneratedField {
9072 Symbol,
9073 Condition,
9074 Slots,
9075 }
9076 impl<'de> serde::Deserialize<'de> for GeneratedField {
9077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9078 where
9079 D: serde::Deserializer<'de>,
9080 {
9081 struct GeneratedVisitor;
9082
9083 impl serde::de::Visitor<'_> for GeneratedVisitor {
9084 type Value = GeneratedField;
9085
9086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9087 write!(formatter, "expected one of: {:?}", &FIELDS)
9088 }
9089
9090 #[allow(unused_variables)]
9091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9092 where
9093 E: serde::de::Error,
9094 {
9095 match value {
9096 "symbol" => Ok(GeneratedField::Symbol),
9097 "condition" => Ok(GeneratedField::Condition),
9098 "slots" => Ok(GeneratedField::Slots),
9099 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9100 }
9101 }
9102 }
9103 deserializer.deserialize_identifier(GeneratedVisitor)
9104 }
9105 }
9106 struct GeneratedVisitor;
9107 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9108 type Value = MatchRecognizeDefine;
9109
9110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9111 formatter.write_str("struct stream_plan.MatchRecognizeDefine")
9112 }
9113
9114 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeDefine, V::Error>
9115 where
9116 V: serde::de::MapAccess<'de>,
9117 {
9118 let mut symbol__ = None;
9119 let mut condition__ = None;
9120 let mut slots__ = None;
9121 while let Some(k) = map_.next_key()? {
9122 match k {
9123 GeneratedField::Symbol => {
9124 if symbol__.is_some() {
9125 return Err(serde::de::Error::duplicate_field("symbol"));
9126 }
9127 symbol__ = Some(map_.next_value()?);
9128 }
9129 GeneratedField::Condition => {
9130 if condition__.is_some() {
9131 return Err(serde::de::Error::duplicate_field("condition"));
9132 }
9133 condition__ = map_.next_value()?;
9134 }
9135 GeneratedField::Slots => {
9136 if slots__.is_some() {
9137 return Err(serde::de::Error::duplicate_field("slots"));
9138 }
9139 slots__ = Some(map_.next_value()?);
9140 }
9141 }
9142 }
9143 Ok(MatchRecognizeDefine {
9144 symbol: symbol__.unwrap_or_default(),
9145 condition: condition__,
9146 slots: slots__.unwrap_or_default(),
9147 })
9148 }
9149 }
9150 deserializer.deserialize_struct("stream_plan.MatchRecognizeDefine", FIELDS, GeneratedVisitor)
9151 }
9152}
9153impl serde::Serialize for MatchRecognizeDefineSlot {
9154 #[allow(deprecated)]
9155 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9156 where
9157 S: serde::Serializer,
9158 {
9159 use serde::ser::SerializeStruct;
9160 let mut len = 0;
9161 if self.kind != 0 {
9162 len += 1;
9163 }
9164 if !self.vars.is_empty() {
9165 len += 1;
9166 }
9167 if self.col_idx != 0 {
9168 len += 1;
9169 }
9170 if self.offset != 0 {
9171 len += 1;
9172 }
9173 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeDefineSlot", len)?;
9174 if self.kind != 0 {
9175 let v = match_recognize_define_slot::Kind::try_from(self.kind)
9176 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
9177 struct_ser.serialize_field("kind", &v)?;
9178 }
9179 if !self.vars.is_empty() {
9180 struct_ser.serialize_field("vars", &self.vars)?;
9181 }
9182 if self.col_idx != 0 {
9183 struct_ser.serialize_field("colIdx", &self.col_idx)?;
9184 }
9185 if self.offset != 0 {
9186 struct_ser.serialize_field("offset", &self.offset)?;
9187 }
9188 struct_ser.end()
9189 }
9190}
9191impl<'de> serde::Deserialize<'de> for MatchRecognizeDefineSlot {
9192 #[allow(deprecated)]
9193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9194 where
9195 D: serde::Deserializer<'de>,
9196 {
9197 const FIELDS: &[&str] = &[
9198 "kind",
9199 "vars",
9200 "col_idx",
9201 "colIdx",
9202 "offset",
9203 ];
9204
9205 #[allow(clippy::enum_variant_names)]
9206 enum GeneratedField {
9207 Kind,
9208 Vars,
9209 ColIdx,
9210 Offset,
9211 }
9212 impl<'de> serde::Deserialize<'de> for GeneratedField {
9213 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9214 where
9215 D: serde::Deserializer<'de>,
9216 {
9217 struct GeneratedVisitor;
9218
9219 impl serde::de::Visitor<'_> for GeneratedVisitor {
9220 type Value = GeneratedField;
9221
9222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9223 write!(formatter, "expected one of: {:?}", &FIELDS)
9224 }
9225
9226 #[allow(unused_variables)]
9227 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9228 where
9229 E: serde::de::Error,
9230 {
9231 match value {
9232 "kind" => Ok(GeneratedField::Kind),
9233 "vars" => Ok(GeneratedField::Vars),
9234 "colIdx" | "col_idx" => Ok(GeneratedField::ColIdx),
9235 "offset" => Ok(GeneratedField::Offset),
9236 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9237 }
9238 }
9239 }
9240 deserializer.deserialize_identifier(GeneratedVisitor)
9241 }
9242 }
9243 struct GeneratedVisitor;
9244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9245 type Value = MatchRecognizeDefineSlot;
9246
9247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9248 formatter.write_str("struct stream_plan.MatchRecognizeDefineSlot")
9249 }
9250
9251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeDefineSlot, V::Error>
9252 where
9253 V: serde::de::MapAccess<'de>,
9254 {
9255 let mut kind__ = None;
9256 let mut vars__ = None;
9257 let mut col_idx__ = None;
9258 let mut offset__ = None;
9259 while let Some(k) = map_.next_key()? {
9260 match k {
9261 GeneratedField::Kind => {
9262 if kind__.is_some() {
9263 return Err(serde::de::Error::duplicate_field("kind"));
9264 }
9265 kind__ = Some(map_.next_value::<match_recognize_define_slot::Kind>()? as i32);
9266 }
9267 GeneratedField::Vars => {
9268 if vars__.is_some() {
9269 return Err(serde::de::Error::duplicate_field("vars"));
9270 }
9271 vars__ = Some(map_.next_value()?);
9272 }
9273 GeneratedField::ColIdx => {
9274 if col_idx__.is_some() {
9275 return Err(serde::de::Error::duplicate_field("colIdx"));
9276 }
9277 col_idx__ =
9278 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9279 ;
9280 }
9281 GeneratedField::Offset => {
9282 if offset__.is_some() {
9283 return Err(serde::de::Error::duplicate_field("offset"));
9284 }
9285 offset__ =
9286 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9287 ;
9288 }
9289 }
9290 }
9291 Ok(MatchRecognizeDefineSlot {
9292 kind: kind__.unwrap_or_default(),
9293 vars: vars__.unwrap_or_default(),
9294 col_idx: col_idx__.unwrap_or_default(),
9295 offset: offset__.unwrap_or_default(),
9296 })
9297 }
9298 }
9299 deserializer.deserialize_struct("stream_plan.MatchRecognizeDefineSlot", FIELDS, GeneratedVisitor)
9300 }
9301}
9302impl serde::Serialize for match_recognize_define_slot::Kind {
9303 #[allow(deprecated)]
9304 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9305 where
9306 S: serde::Serializer,
9307 {
9308 let variant = match self {
9309 Self::Unspecified => "KIND_UNSPECIFIED",
9310 Self::SelfCol => "KIND_SELF_COL",
9311 Self::Prev => "KIND_PREV",
9312 Self::Next => "KIND_NEXT",
9313 Self::RunningFirst => "KIND_RUNNING_FIRST",
9314 Self::RunningLast => "KIND_RUNNING_LAST",
9315 };
9316 serializer.serialize_str(variant)
9317 }
9318}
9319impl<'de> serde::Deserialize<'de> for match_recognize_define_slot::Kind {
9320 #[allow(deprecated)]
9321 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9322 where
9323 D: serde::Deserializer<'de>,
9324 {
9325 const FIELDS: &[&str] = &[
9326 "KIND_UNSPECIFIED",
9327 "KIND_SELF_COL",
9328 "KIND_PREV",
9329 "KIND_NEXT",
9330 "KIND_RUNNING_FIRST",
9331 "KIND_RUNNING_LAST",
9332 ];
9333
9334 struct GeneratedVisitor;
9335
9336 impl serde::de::Visitor<'_> for GeneratedVisitor {
9337 type Value = match_recognize_define_slot::Kind;
9338
9339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9340 write!(formatter, "expected one of: {:?}", &FIELDS)
9341 }
9342
9343 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9344 where
9345 E: serde::de::Error,
9346 {
9347 i32::try_from(v)
9348 .ok()
9349 .and_then(|x| x.try_into().ok())
9350 .ok_or_else(|| {
9351 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9352 })
9353 }
9354
9355 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9356 where
9357 E: serde::de::Error,
9358 {
9359 i32::try_from(v)
9360 .ok()
9361 .and_then(|x| x.try_into().ok())
9362 .ok_or_else(|| {
9363 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9364 })
9365 }
9366
9367 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9368 where
9369 E: serde::de::Error,
9370 {
9371 match value {
9372 "KIND_UNSPECIFIED" => Ok(match_recognize_define_slot::Kind::Unspecified),
9373 "KIND_SELF_COL" => Ok(match_recognize_define_slot::Kind::SelfCol),
9374 "KIND_PREV" => Ok(match_recognize_define_slot::Kind::Prev),
9375 "KIND_NEXT" => Ok(match_recognize_define_slot::Kind::Next),
9376 "KIND_RUNNING_FIRST" => Ok(match_recognize_define_slot::Kind::RunningFirst),
9377 "KIND_RUNNING_LAST" => Ok(match_recognize_define_slot::Kind::RunningLast),
9378 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9379 }
9380 }
9381 }
9382 deserializer.deserialize_any(GeneratedVisitor)
9383 }
9384}
9385impl serde::Serialize for MatchRecognizeInputMode {
9386 #[allow(deprecated)]
9387 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9388 where
9389 S: serde::Serializer,
9390 {
9391 let variant = match self {
9392 Self::Unspecified => "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED",
9393 Self::EventTime => "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME",
9394 Self::ProcessingTime => "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME",
9395 };
9396 serializer.serialize_str(variant)
9397 }
9398}
9399impl<'de> serde::Deserialize<'de> for MatchRecognizeInputMode {
9400 #[allow(deprecated)]
9401 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9402 where
9403 D: serde::Deserializer<'de>,
9404 {
9405 const FIELDS: &[&str] = &[
9406 "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED",
9407 "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME",
9408 "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME",
9409 ];
9410
9411 struct GeneratedVisitor;
9412
9413 impl serde::de::Visitor<'_> for GeneratedVisitor {
9414 type Value = MatchRecognizeInputMode;
9415
9416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9417 write!(formatter, "expected one of: {:?}", &FIELDS)
9418 }
9419
9420 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9421 where
9422 E: serde::de::Error,
9423 {
9424 i32::try_from(v)
9425 .ok()
9426 .and_then(|x| x.try_into().ok())
9427 .ok_or_else(|| {
9428 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9429 })
9430 }
9431
9432 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9433 where
9434 E: serde::de::Error,
9435 {
9436 i32::try_from(v)
9437 .ok()
9438 .and_then(|x| x.try_into().ok())
9439 .ok_or_else(|| {
9440 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9441 })
9442 }
9443
9444 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9445 where
9446 E: serde::de::Error,
9447 {
9448 match value {
9449 "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED" => Ok(MatchRecognizeInputMode::Unspecified),
9450 "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME" => Ok(MatchRecognizeInputMode::EventTime),
9451 "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME" => Ok(MatchRecognizeInputMode::ProcessingTime),
9452 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9453 }
9454 }
9455 }
9456 deserializer.deserialize_any(GeneratedVisitor)
9457 }
9458}
9459impl serde::Serialize for MatchRecognizeMeasure {
9460 #[allow(deprecated)]
9461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9462 where
9463 S: serde::Serializer,
9464 {
9465 use serde::ser::SerializeStruct;
9466 let mut len = 0;
9467 if self.expr.is_some() {
9468 len += 1;
9469 }
9470 if !self.name.is_empty() {
9471 len += 1;
9472 }
9473 if !self.slots.is_empty() {
9474 len += 1;
9475 }
9476 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeMeasure", len)?;
9477 if let Some(v) = self.expr.as_ref() {
9478 struct_ser.serialize_field("expr", v)?;
9479 }
9480 if !self.name.is_empty() {
9481 struct_ser.serialize_field("name", &self.name)?;
9482 }
9483 if !self.slots.is_empty() {
9484 struct_ser.serialize_field("slots", &self.slots)?;
9485 }
9486 struct_ser.end()
9487 }
9488}
9489impl<'de> serde::Deserialize<'de> for MatchRecognizeMeasure {
9490 #[allow(deprecated)]
9491 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9492 where
9493 D: serde::Deserializer<'de>,
9494 {
9495 const FIELDS: &[&str] = &[
9496 "expr",
9497 "name",
9498 "slots",
9499 ];
9500
9501 #[allow(clippy::enum_variant_names)]
9502 enum GeneratedField {
9503 Expr,
9504 Name,
9505 Slots,
9506 }
9507 impl<'de> serde::Deserialize<'de> for GeneratedField {
9508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9509 where
9510 D: serde::Deserializer<'de>,
9511 {
9512 struct GeneratedVisitor;
9513
9514 impl serde::de::Visitor<'_> for GeneratedVisitor {
9515 type Value = GeneratedField;
9516
9517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9518 write!(formatter, "expected one of: {:?}", &FIELDS)
9519 }
9520
9521 #[allow(unused_variables)]
9522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9523 where
9524 E: serde::de::Error,
9525 {
9526 match value {
9527 "expr" => Ok(GeneratedField::Expr),
9528 "name" => Ok(GeneratedField::Name),
9529 "slots" => Ok(GeneratedField::Slots),
9530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9531 }
9532 }
9533 }
9534 deserializer.deserialize_identifier(GeneratedVisitor)
9535 }
9536 }
9537 struct GeneratedVisitor;
9538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9539 type Value = MatchRecognizeMeasure;
9540
9541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9542 formatter.write_str("struct stream_plan.MatchRecognizeMeasure")
9543 }
9544
9545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeMeasure, V::Error>
9546 where
9547 V: serde::de::MapAccess<'de>,
9548 {
9549 let mut expr__ = None;
9550 let mut name__ = None;
9551 let mut slots__ = None;
9552 while let Some(k) = map_.next_key()? {
9553 match k {
9554 GeneratedField::Expr => {
9555 if expr__.is_some() {
9556 return Err(serde::de::Error::duplicate_field("expr"));
9557 }
9558 expr__ = map_.next_value()?;
9559 }
9560 GeneratedField::Name => {
9561 if name__.is_some() {
9562 return Err(serde::de::Error::duplicate_field("name"));
9563 }
9564 name__ = Some(map_.next_value()?);
9565 }
9566 GeneratedField::Slots => {
9567 if slots__.is_some() {
9568 return Err(serde::de::Error::duplicate_field("slots"));
9569 }
9570 slots__ = Some(map_.next_value()?);
9571 }
9572 }
9573 }
9574 Ok(MatchRecognizeMeasure {
9575 expr: expr__,
9576 name: name__.unwrap_or_default(),
9577 slots: slots__.unwrap_or_default(),
9578 })
9579 }
9580 }
9581 deserializer.deserialize_struct("stream_plan.MatchRecognizeMeasure", FIELDS, GeneratedVisitor)
9582 }
9583}
9584impl serde::Serialize for MatchRecognizeMeasureSlot {
9585 #[allow(deprecated)]
9586 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9587 where
9588 S: serde::Serializer,
9589 {
9590 use serde::ser::SerializeStruct;
9591 let mut len = 0;
9592 if self.kind != 0 {
9593 len += 1;
9594 }
9595 if !self.vars.is_empty() {
9596 len += 1;
9597 }
9598 if self.col_idx != 0 {
9599 len += 1;
9600 }
9601 if self.data_type.is_some() {
9602 len += 1;
9603 }
9604 if self.agg_call.is_some() {
9605 len += 1;
9606 }
9607 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeMeasureSlot", len)?;
9608 if self.kind != 0 {
9609 let v = match_recognize_measure_slot::Kind::try_from(self.kind)
9610 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
9611 struct_ser.serialize_field("kind", &v)?;
9612 }
9613 if !self.vars.is_empty() {
9614 struct_ser.serialize_field("vars", &self.vars)?;
9615 }
9616 if self.col_idx != 0 {
9617 struct_ser.serialize_field("colIdx", &self.col_idx)?;
9618 }
9619 if let Some(v) = self.data_type.as_ref() {
9620 struct_ser.serialize_field("dataType", v)?;
9621 }
9622 if let Some(v) = self.agg_call.as_ref() {
9623 struct_ser.serialize_field("aggCall", v)?;
9624 }
9625 struct_ser.end()
9626 }
9627}
9628impl<'de> serde::Deserialize<'de> for MatchRecognizeMeasureSlot {
9629 #[allow(deprecated)]
9630 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9631 where
9632 D: serde::Deserializer<'de>,
9633 {
9634 const FIELDS: &[&str] = &[
9635 "kind",
9636 "vars",
9637 "col_idx",
9638 "colIdx",
9639 "data_type",
9640 "dataType",
9641 "agg_call",
9642 "aggCall",
9643 ];
9644
9645 #[allow(clippy::enum_variant_names)]
9646 enum GeneratedField {
9647 Kind,
9648 Vars,
9649 ColIdx,
9650 DataType,
9651 AggCall,
9652 }
9653 impl<'de> serde::Deserialize<'de> for GeneratedField {
9654 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9655 where
9656 D: serde::Deserializer<'de>,
9657 {
9658 struct GeneratedVisitor;
9659
9660 impl serde::de::Visitor<'_> for GeneratedVisitor {
9661 type Value = GeneratedField;
9662
9663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9664 write!(formatter, "expected one of: {:?}", &FIELDS)
9665 }
9666
9667 #[allow(unused_variables)]
9668 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9669 where
9670 E: serde::de::Error,
9671 {
9672 match value {
9673 "kind" => Ok(GeneratedField::Kind),
9674 "vars" => Ok(GeneratedField::Vars),
9675 "colIdx" | "col_idx" => Ok(GeneratedField::ColIdx),
9676 "dataType" | "data_type" => Ok(GeneratedField::DataType),
9677 "aggCall" | "agg_call" => Ok(GeneratedField::AggCall),
9678 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9679 }
9680 }
9681 }
9682 deserializer.deserialize_identifier(GeneratedVisitor)
9683 }
9684 }
9685 struct GeneratedVisitor;
9686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9687 type Value = MatchRecognizeMeasureSlot;
9688
9689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9690 formatter.write_str("struct stream_plan.MatchRecognizeMeasureSlot")
9691 }
9692
9693 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeMeasureSlot, V::Error>
9694 where
9695 V: serde::de::MapAccess<'de>,
9696 {
9697 let mut kind__ = None;
9698 let mut vars__ = None;
9699 let mut col_idx__ = None;
9700 let mut data_type__ = None;
9701 let mut agg_call__ = None;
9702 while let Some(k) = map_.next_key()? {
9703 match k {
9704 GeneratedField::Kind => {
9705 if kind__.is_some() {
9706 return Err(serde::de::Error::duplicate_field("kind"));
9707 }
9708 kind__ = Some(map_.next_value::<match_recognize_measure_slot::Kind>()? as i32);
9709 }
9710 GeneratedField::Vars => {
9711 if vars__.is_some() {
9712 return Err(serde::de::Error::duplicate_field("vars"));
9713 }
9714 vars__ = Some(map_.next_value()?);
9715 }
9716 GeneratedField::ColIdx => {
9717 if col_idx__.is_some() {
9718 return Err(serde::de::Error::duplicate_field("colIdx"));
9719 }
9720 col_idx__ =
9721 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9722 ;
9723 }
9724 GeneratedField::DataType => {
9725 if data_type__.is_some() {
9726 return Err(serde::de::Error::duplicate_field("dataType"));
9727 }
9728 data_type__ = map_.next_value()?;
9729 }
9730 GeneratedField::AggCall => {
9731 if agg_call__.is_some() {
9732 return Err(serde::de::Error::duplicate_field("aggCall"));
9733 }
9734 agg_call__ = map_.next_value()?;
9735 }
9736 }
9737 }
9738 Ok(MatchRecognizeMeasureSlot {
9739 kind: kind__.unwrap_or_default(),
9740 vars: vars__.unwrap_or_default(),
9741 col_idx: col_idx__.unwrap_or_default(),
9742 data_type: data_type__,
9743 agg_call: agg_call__,
9744 })
9745 }
9746 }
9747 deserializer.deserialize_struct("stream_plan.MatchRecognizeMeasureSlot", FIELDS, GeneratedVisitor)
9748 }
9749}
9750impl serde::Serialize for match_recognize_measure_slot::Kind {
9751 #[allow(deprecated)]
9752 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9753 where
9754 S: serde::Serializer,
9755 {
9756 let variant = match self {
9757 Self::Unspecified => "KIND_UNSPECIFIED",
9758 Self::Last => "KIND_LAST",
9759 Self::First => "KIND_FIRST",
9760 Self::Classifier => "KIND_CLASSIFIER",
9761 Self::CountStar => "KIND_COUNT_STAR",
9762 Self::Count => "KIND_COUNT",
9763 Self::Min => "KIND_MIN",
9764 Self::Max => "KIND_MAX",
9765 Self::Sum => "KIND_SUM",
9766 };
9767 serializer.serialize_str(variant)
9768 }
9769}
9770impl<'de> serde::Deserialize<'de> for match_recognize_measure_slot::Kind {
9771 #[allow(deprecated)]
9772 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9773 where
9774 D: serde::Deserializer<'de>,
9775 {
9776 const FIELDS: &[&str] = &[
9777 "KIND_UNSPECIFIED",
9778 "KIND_LAST",
9779 "KIND_FIRST",
9780 "KIND_CLASSIFIER",
9781 "KIND_COUNT_STAR",
9782 "KIND_COUNT",
9783 "KIND_MIN",
9784 "KIND_MAX",
9785 "KIND_SUM",
9786 ];
9787
9788 struct GeneratedVisitor;
9789
9790 impl serde::de::Visitor<'_> for GeneratedVisitor {
9791 type Value = match_recognize_measure_slot::Kind;
9792
9793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9794 write!(formatter, "expected one of: {:?}", &FIELDS)
9795 }
9796
9797 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9798 where
9799 E: serde::de::Error,
9800 {
9801 i32::try_from(v)
9802 .ok()
9803 .and_then(|x| x.try_into().ok())
9804 .ok_or_else(|| {
9805 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9806 })
9807 }
9808
9809 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9810 where
9811 E: serde::de::Error,
9812 {
9813 i32::try_from(v)
9814 .ok()
9815 .and_then(|x| x.try_into().ok())
9816 .ok_or_else(|| {
9817 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9818 })
9819 }
9820
9821 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9822 where
9823 E: serde::de::Error,
9824 {
9825 match value {
9826 "KIND_UNSPECIFIED" => Ok(match_recognize_measure_slot::Kind::Unspecified),
9827 "KIND_LAST" => Ok(match_recognize_measure_slot::Kind::Last),
9828 "KIND_FIRST" => Ok(match_recognize_measure_slot::Kind::First),
9829 "KIND_CLASSIFIER" => Ok(match_recognize_measure_slot::Kind::Classifier),
9830 "KIND_COUNT_STAR" => Ok(match_recognize_measure_slot::Kind::CountStar),
9831 "KIND_COUNT" => Ok(match_recognize_measure_slot::Kind::Count),
9832 "KIND_MIN" => Ok(match_recognize_measure_slot::Kind::Min),
9833 "KIND_MAX" => Ok(match_recognize_measure_slot::Kind::Max),
9834 "KIND_SUM" => Ok(match_recognize_measure_slot::Kind::Sum),
9835 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9836 }
9837 }
9838 }
9839 deserializer.deserialize_any(GeneratedVisitor)
9840 }
9841}
9842impl serde::Serialize for MatchRecognizeNode {
9843 #[allow(deprecated)]
9844 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9845 where
9846 S: serde::Serializer,
9847 {
9848 use serde::ser::SerializeStruct;
9849 let mut len = 0;
9850 if !self.partition_by.is_empty() {
9851 len += 1;
9852 }
9853 if !self.order_by.is_empty() {
9854 len += 1;
9855 }
9856 if !self.measures.is_empty() {
9857 len += 1;
9858 }
9859 if !self.defines.is_empty() {
9860 len += 1;
9861 }
9862 if self.pattern_node.is_some() {
9863 len += 1;
9864 }
9865 if self.state_table.is_some() {
9866 len += 1;
9867 }
9868 if self.after_match_skip.is_some() {
9869 len += 1;
9870 }
9871 if self.within.is_some() {
9872 len += 1;
9873 }
9874 if self.within_deadline.is_some() {
9875 len += 1;
9876 }
9877 if self.input_mode != 0 {
9878 len += 1;
9879 }
9880 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeNode", len)?;
9881 if !self.partition_by.is_empty() {
9882 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
9883 }
9884 if !self.order_by.is_empty() {
9885 struct_ser.serialize_field("orderBy", &self.order_by)?;
9886 }
9887 if !self.measures.is_empty() {
9888 struct_ser.serialize_field("measures", &self.measures)?;
9889 }
9890 if !self.defines.is_empty() {
9891 struct_ser.serialize_field("defines", &self.defines)?;
9892 }
9893 if let Some(v) = self.pattern_node.as_ref() {
9894 struct_ser.serialize_field("patternNode", v)?;
9895 }
9896 if let Some(v) = self.state_table.as_ref() {
9897 struct_ser.serialize_field("stateTable", v)?;
9898 }
9899 if let Some(v) = self.after_match_skip.as_ref() {
9900 struct_ser.serialize_field("afterMatchSkip", v)?;
9901 }
9902 if let Some(v) = self.within.as_ref() {
9903 struct_ser.serialize_field("within", v)?;
9904 }
9905 if let Some(v) = self.within_deadline.as_ref() {
9906 struct_ser.serialize_field("withinDeadline", v)?;
9907 }
9908 if self.input_mode != 0 {
9909 let v = MatchRecognizeInputMode::try_from(self.input_mode)
9910 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.input_mode)))?;
9911 struct_ser.serialize_field("inputMode", &v)?;
9912 }
9913 struct_ser.end()
9914 }
9915}
9916impl<'de> serde::Deserialize<'de> for MatchRecognizeNode {
9917 #[allow(deprecated)]
9918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9919 where
9920 D: serde::Deserializer<'de>,
9921 {
9922 const FIELDS: &[&str] = &[
9923 "partition_by",
9924 "partitionBy",
9925 "order_by",
9926 "orderBy",
9927 "measures",
9928 "defines",
9929 "pattern_node",
9930 "patternNode",
9931 "state_table",
9932 "stateTable",
9933 "after_match_skip",
9934 "afterMatchSkip",
9935 "within",
9936 "within_deadline",
9937 "withinDeadline",
9938 "input_mode",
9939 "inputMode",
9940 ];
9941
9942 #[allow(clippy::enum_variant_names)]
9943 enum GeneratedField {
9944 PartitionBy,
9945 OrderBy,
9946 Measures,
9947 Defines,
9948 PatternNode,
9949 StateTable,
9950 AfterMatchSkip,
9951 Within,
9952 WithinDeadline,
9953 InputMode,
9954 }
9955 impl<'de> serde::Deserialize<'de> for GeneratedField {
9956 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9957 where
9958 D: serde::Deserializer<'de>,
9959 {
9960 struct GeneratedVisitor;
9961
9962 impl serde::de::Visitor<'_> for GeneratedVisitor {
9963 type Value = GeneratedField;
9964
9965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9966 write!(formatter, "expected one of: {:?}", &FIELDS)
9967 }
9968
9969 #[allow(unused_variables)]
9970 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9971 where
9972 E: serde::de::Error,
9973 {
9974 match value {
9975 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
9976 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
9977 "measures" => Ok(GeneratedField::Measures),
9978 "defines" => Ok(GeneratedField::Defines),
9979 "patternNode" | "pattern_node" => Ok(GeneratedField::PatternNode),
9980 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9981 "afterMatchSkip" | "after_match_skip" => Ok(GeneratedField::AfterMatchSkip),
9982 "within" => Ok(GeneratedField::Within),
9983 "withinDeadline" | "within_deadline" => Ok(GeneratedField::WithinDeadline),
9984 "inputMode" | "input_mode" => Ok(GeneratedField::InputMode),
9985 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9986 }
9987 }
9988 }
9989 deserializer.deserialize_identifier(GeneratedVisitor)
9990 }
9991 }
9992 struct GeneratedVisitor;
9993 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9994 type Value = MatchRecognizeNode;
9995
9996 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9997 formatter.write_str("struct stream_plan.MatchRecognizeNode")
9998 }
9999
10000 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeNode, V::Error>
10001 where
10002 V: serde::de::MapAccess<'de>,
10003 {
10004 let mut partition_by__ = None;
10005 let mut order_by__ = None;
10006 let mut measures__ = None;
10007 let mut defines__ = None;
10008 let mut pattern_node__ = None;
10009 let mut state_table__ = None;
10010 let mut after_match_skip__ = None;
10011 let mut within__ = None;
10012 let mut within_deadline__ = None;
10013 let mut input_mode__ = None;
10014 while let Some(k) = map_.next_key()? {
10015 match k {
10016 GeneratedField::PartitionBy => {
10017 if partition_by__.is_some() {
10018 return Err(serde::de::Error::duplicate_field("partitionBy"));
10019 }
10020 partition_by__ =
10021 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10022 .into_iter().map(|x| x.0).collect())
10023 ;
10024 }
10025 GeneratedField::OrderBy => {
10026 if order_by__.is_some() {
10027 return Err(serde::de::Error::duplicate_field("orderBy"));
10028 }
10029 order_by__ = Some(map_.next_value()?);
10030 }
10031 GeneratedField::Measures => {
10032 if measures__.is_some() {
10033 return Err(serde::de::Error::duplicate_field("measures"));
10034 }
10035 measures__ = Some(map_.next_value()?);
10036 }
10037 GeneratedField::Defines => {
10038 if defines__.is_some() {
10039 return Err(serde::de::Error::duplicate_field("defines"));
10040 }
10041 defines__ = Some(map_.next_value()?);
10042 }
10043 GeneratedField::PatternNode => {
10044 if pattern_node__.is_some() {
10045 return Err(serde::de::Error::duplicate_field("patternNode"));
10046 }
10047 pattern_node__ = map_.next_value()?;
10048 }
10049 GeneratedField::StateTable => {
10050 if state_table__.is_some() {
10051 return Err(serde::de::Error::duplicate_field("stateTable"));
10052 }
10053 state_table__ = map_.next_value()?;
10054 }
10055 GeneratedField::AfterMatchSkip => {
10056 if after_match_skip__.is_some() {
10057 return Err(serde::de::Error::duplicate_field("afterMatchSkip"));
10058 }
10059 after_match_skip__ = map_.next_value()?;
10060 }
10061 GeneratedField::Within => {
10062 if within__.is_some() {
10063 return Err(serde::de::Error::duplicate_field("within"));
10064 }
10065 within__ = map_.next_value()?;
10066 }
10067 GeneratedField::WithinDeadline => {
10068 if within_deadline__.is_some() {
10069 return Err(serde::de::Error::duplicate_field("withinDeadline"));
10070 }
10071 within_deadline__ = map_.next_value()?;
10072 }
10073 GeneratedField::InputMode => {
10074 if input_mode__.is_some() {
10075 return Err(serde::de::Error::duplicate_field("inputMode"));
10076 }
10077 input_mode__ = Some(map_.next_value::<MatchRecognizeInputMode>()? as i32);
10078 }
10079 }
10080 }
10081 Ok(MatchRecognizeNode {
10082 partition_by: partition_by__.unwrap_or_default(),
10083 order_by: order_by__.unwrap_or_default(),
10084 measures: measures__.unwrap_or_default(),
10085 defines: defines__.unwrap_or_default(),
10086 pattern_node: pattern_node__,
10087 state_table: state_table__,
10088 after_match_skip: after_match_skip__,
10089 within: within__,
10090 within_deadline: within_deadline__,
10091 input_mode: input_mode__.unwrap_or_default(),
10092 })
10093 }
10094 }
10095 deserializer.deserialize_struct("stream_plan.MatchRecognizeNode", FIELDS, GeneratedVisitor)
10096 }
10097}
10098impl serde::Serialize for MatchRecognizePatternNode {
10099 #[allow(deprecated)]
10100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10101 where
10102 S: serde::Serializer,
10103 {
10104 use serde::ser::SerializeStruct;
10105 let mut len = 0;
10106 if self.node.is_some() {
10107 len += 1;
10108 }
10109 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePatternNode", len)?;
10110 if let Some(v) = self.node.as_ref() {
10111 match v {
10112 match_recognize_pattern_node::Node::Var(v) => {
10113 struct_ser.serialize_field("var", v)?;
10114 }
10115 match_recognize_pattern_node::Node::Concat(v) => {
10116 struct_ser.serialize_field("concat", v)?;
10117 }
10118 match_recognize_pattern_node::Node::Alternation(v) => {
10119 struct_ser.serialize_field("alternation", v)?;
10120 }
10121 match_recognize_pattern_node::Node::Quantified(v) => {
10122 struct_ser.serialize_field("quantified", v)?;
10123 }
10124 match_recognize_pattern_node::Node::Permute(v) => {
10125 struct_ser.serialize_field("permute", v)?;
10126 }
10127 }
10128 }
10129 struct_ser.end()
10130 }
10131}
10132impl<'de> serde::Deserialize<'de> for MatchRecognizePatternNode {
10133 #[allow(deprecated)]
10134 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10135 where
10136 D: serde::Deserializer<'de>,
10137 {
10138 const FIELDS: &[&str] = &[
10139 "var",
10140 "concat",
10141 "alternation",
10142 "quantified",
10143 "permute",
10144 ];
10145
10146 #[allow(clippy::enum_variant_names)]
10147 enum GeneratedField {
10148 Var,
10149 Concat,
10150 Alternation,
10151 Quantified,
10152 Permute,
10153 }
10154 impl<'de> serde::Deserialize<'de> for GeneratedField {
10155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10156 where
10157 D: serde::Deserializer<'de>,
10158 {
10159 struct GeneratedVisitor;
10160
10161 impl serde::de::Visitor<'_> for GeneratedVisitor {
10162 type Value = GeneratedField;
10163
10164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10165 write!(formatter, "expected one of: {:?}", &FIELDS)
10166 }
10167
10168 #[allow(unused_variables)]
10169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10170 where
10171 E: serde::de::Error,
10172 {
10173 match value {
10174 "var" => Ok(GeneratedField::Var),
10175 "concat" => Ok(GeneratedField::Concat),
10176 "alternation" => Ok(GeneratedField::Alternation),
10177 "quantified" => Ok(GeneratedField::Quantified),
10178 "permute" => Ok(GeneratedField::Permute),
10179 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10180 }
10181 }
10182 }
10183 deserializer.deserialize_identifier(GeneratedVisitor)
10184 }
10185 }
10186 struct GeneratedVisitor;
10187 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10188 type Value = MatchRecognizePatternNode;
10189
10190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10191 formatter.write_str("struct stream_plan.MatchRecognizePatternNode")
10192 }
10193
10194 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePatternNode, V::Error>
10195 where
10196 V: serde::de::MapAccess<'de>,
10197 {
10198 let mut node__ = None;
10199 while let Some(k) = map_.next_key()? {
10200 match k {
10201 GeneratedField::Var => {
10202 if node__.is_some() {
10203 return Err(serde::de::Error::duplicate_field("var"));
10204 }
10205 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Var);
10206 }
10207 GeneratedField::Concat => {
10208 if node__.is_some() {
10209 return Err(serde::de::Error::duplicate_field("concat"));
10210 }
10211 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Concat)
10212;
10213 }
10214 GeneratedField::Alternation => {
10215 if node__.is_some() {
10216 return Err(serde::de::Error::duplicate_field("alternation"));
10217 }
10218 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Alternation)
10219;
10220 }
10221 GeneratedField::Quantified => {
10222 if node__.is_some() {
10223 return Err(serde::de::Error::duplicate_field("quantified"));
10224 }
10225 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Quantified)
10226;
10227 }
10228 GeneratedField::Permute => {
10229 if node__.is_some() {
10230 return Err(serde::de::Error::duplicate_field("permute"));
10231 }
10232 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Permute)
10233;
10234 }
10235 }
10236 }
10237 Ok(MatchRecognizePatternNode {
10238 node: node__,
10239 })
10240 }
10241 }
10242 deserializer.deserialize_struct("stream_plan.MatchRecognizePatternNode", FIELDS, GeneratedVisitor)
10243 }
10244}
10245impl serde::Serialize for MatchRecognizePatternSeq {
10246 #[allow(deprecated)]
10247 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10248 where
10249 S: serde::Serializer,
10250 {
10251 use serde::ser::SerializeStruct;
10252 let mut len = 0;
10253 if !self.patterns.is_empty() {
10254 len += 1;
10255 }
10256 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePatternSeq", len)?;
10257 if !self.patterns.is_empty() {
10258 struct_ser.serialize_field("patterns", &self.patterns)?;
10259 }
10260 struct_ser.end()
10261 }
10262}
10263impl<'de> serde::Deserialize<'de> for MatchRecognizePatternSeq {
10264 #[allow(deprecated)]
10265 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10266 where
10267 D: serde::Deserializer<'de>,
10268 {
10269 const FIELDS: &[&str] = &[
10270 "patterns",
10271 ];
10272
10273 #[allow(clippy::enum_variant_names)]
10274 enum GeneratedField {
10275 Patterns,
10276 }
10277 impl<'de> serde::Deserialize<'de> for GeneratedField {
10278 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10279 where
10280 D: serde::Deserializer<'de>,
10281 {
10282 struct GeneratedVisitor;
10283
10284 impl serde::de::Visitor<'_> for GeneratedVisitor {
10285 type Value = GeneratedField;
10286
10287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10288 write!(formatter, "expected one of: {:?}", &FIELDS)
10289 }
10290
10291 #[allow(unused_variables)]
10292 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10293 where
10294 E: serde::de::Error,
10295 {
10296 match value {
10297 "patterns" => Ok(GeneratedField::Patterns),
10298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10299 }
10300 }
10301 }
10302 deserializer.deserialize_identifier(GeneratedVisitor)
10303 }
10304 }
10305 struct GeneratedVisitor;
10306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10307 type Value = MatchRecognizePatternSeq;
10308
10309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10310 formatter.write_str("struct stream_plan.MatchRecognizePatternSeq")
10311 }
10312
10313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePatternSeq, V::Error>
10314 where
10315 V: serde::de::MapAccess<'de>,
10316 {
10317 let mut patterns__ = None;
10318 while let Some(k) = map_.next_key()? {
10319 match k {
10320 GeneratedField::Patterns => {
10321 if patterns__.is_some() {
10322 return Err(serde::de::Error::duplicate_field("patterns"));
10323 }
10324 patterns__ = Some(map_.next_value()?);
10325 }
10326 }
10327 }
10328 Ok(MatchRecognizePatternSeq {
10329 patterns: patterns__.unwrap_or_default(),
10330 })
10331 }
10332 }
10333 deserializer.deserialize_struct("stream_plan.MatchRecognizePatternSeq", FIELDS, GeneratedVisitor)
10334 }
10335}
10336impl serde::Serialize for MatchRecognizePermutePattern {
10337 #[allow(deprecated)]
10338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10339 where
10340 S: serde::Serializer,
10341 {
10342 use serde::ser::SerializeStruct;
10343 let mut len = 0;
10344 if !self.vars.is_empty() {
10345 len += 1;
10346 }
10347 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePermutePattern", len)?;
10348 if !self.vars.is_empty() {
10349 struct_ser.serialize_field("vars", &self.vars)?;
10350 }
10351 struct_ser.end()
10352 }
10353}
10354impl<'de> serde::Deserialize<'de> for MatchRecognizePermutePattern {
10355 #[allow(deprecated)]
10356 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10357 where
10358 D: serde::Deserializer<'de>,
10359 {
10360 const FIELDS: &[&str] = &[
10361 "vars",
10362 ];
10363
10364 #[allow(clippy::enum_variant_names)]
10365 enum GeneratedField {
10366 Vars,
10367 }
10368 impl<'de> serde::Deserialize<'de> for GeneratedField {
10369 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10370 where
10371 D: serde::Deserializer<'de>,
10372 {
10373 struct GeneratedVisitor;
10374
10375 impl serde::de::Visitor<'_> for GeneratedVisitor {
10376 type Value = GeneratedField;
10377
10378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10379 write!(formatter, "expected one of: {:?}", &FIELDS)
10380 }
10381
10382 #[allow(unused_variables)]
10383 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10384 where
10385 E: serde::de::Error,
10386 {
10387 match value {
10388 "vars" => Ok(GeneratedField::Vars),
10389 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10390 }
10391 }
10392 }
10393 deserializer.deserialize_identifier(GeneratedVisitor)
10394 }
10395 }
10396 struct GeneratedVisitor;
10397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10398 type Value = MatchRecognizePermutePattern;
10399
10400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10401 formatter.write_str("struct stream_plan.MatchRecognizePermutePattern")
10402 }
10403
10404 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePermutePattern, V::Error>
10405 where
10406 V: serde::de::MapAccess<'de>,
10407 {
10408 let mut vars__ = None;
10409 while let Some(k) = map_.next_key()? {
10410 match k {
10411 GeneratedField::Vars => {
10412 if vars__.is_some() {
10413 return Err(serde::de::Error::duplicate_field("vars"));
10414 }
10415 vars__ = Some(map_.next_value()?);
10416 }
10417 }
10418 }
10419 Ok(MatchRecognizePermutePattern {
10420 vars: vars__.unwrap_or_default(),
10421 })
10422 }
10423 }
10424 deserializer.deserialize_struct("stream_plan.MatchRecognizePermutePattern", FIELDS, GeneratedVisitor)
10425 }
10426}
10427impl serde::Serialize for MatchRecognizeQuantifiedPattern {
10428 #[allow(deprecated)]
10429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10430 where
10431 S: serde::Serializer,
10432 {
10433 use serde::ser::SerializeStruct;
10434 let mut len = 0;
10435 if self.inner.is_some() {
10436 len += 1;
10437 }
10438 if self.quantifier.is_some() {
10439 len += 1;
10440 }
10441 if self.reluctant {
10442 len += 1;
10443 }
10444 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeQuantifiedPattern", len)?;
10445 if let Some(v) = self.inner.as_ref() {
10446 struct_ser.serialize_field("inner", v)?;
10447 }
10448 if let Some(v) = self.quantifier.as_ref() {
10449 struct_ser.serialize_field("quantifier", v)?;
10450 }
10451 if self.reluctant {
10452 struct_ser.serialize_field("reluctant", &self.reluctant)?;
10453 }
10454 struct_ser.end()
10455 }
10456}
10457impl<'de> serde::Deserialize<'de> for MatchRecognizeQuantifiedPattern {
10458 #[allow(deprecated)]
10459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10460 where
10461 D: serde::Deserializer<'de>,
10462 {
10463 const FIELDS: &[&str] = &[
10464 "inner",
10465 "quantifier",
10466 "reluctant",
10467 ];
10468
10469 #[allow(clippy::enum_variant_names)]
10470 enum GeneratedField {
10471 Inner,
10472 Quantifier,
10473 Reluctant,
10474 }
10475 impl<'de> serde::Deserialize<'de> for GeneratedField {
10476 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10477 where
10478 D: serde::Deserializer<'de>,
10479 {
10480 struct GeneratedVisitor;
10481
10482 impl serde::de::Visitor<'_> for GeneratedVisitor {
10483 type Value = GeneratedField;
10484
10485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10486 write!(formatter, "expected one of: {:?}", &FIELDS)
10487 }
10488
10489 #[allow(unused_variables)]
10490 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10491 where
10492 E: serde::de::Error,
10493 {
10494 match value {
10495 "inner" => Ok(GeneratedField::Inner),
10496 "quantifier" => Ok(GeneratedField::Quantifier),
10497 "reluctant" => Ok(GeneratedField::Reluctant),
10498 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10499 }
10500 }
10501 }
10502 deserializer.deserialize_identifier(GeneratedVisitor)
10503 }
10504 }
10505 struct GeneratedVisitor;
10506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10507 type Value = MatchRecognizeQuantifiedPattern;
10508
10509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10510 formatter.write_str("struct stream_plan.MatchRecognizeQuantifiedPattern")
10511 }
10512
10513 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeQuantifiedPattern, V::Error>
10514 where
10515 V: serde::de::MapAccess<'de>,
10516 {
10517 let mut inner__ = None;
10518 let mut quantifier__ = None;
10519 let mut reluctant__ = None;
10520 while let Some(k) = map_.next_key()? {
10521 match k {
10522 GeneratedField::Inner => {
10523 if inner__.is_some() {
10524 return Err(serde::de::Error::duplicate_field("inner"));
10525 }
10526 inner__ = map_.next_value()?;
10527 }
10528 GeneratedField::Quantifier => {
10529 if quantifier__.is_some() {
10530 return Err(serde::de::Error::duplicate_field("quantifier"));
10531 }
10532 quantifier__ = map_.next_value()?;
10533 }
10534 GeneratedField::Reluctant => {
10535 if reluctant__.is_some() {
10536 return Err(serde::de::Error::duplicate_field("reluctant"));
10537 }
10538 reluctant__ = Some(map_.next_value()?);
10539 }
10540 }
10541 }
10542 Ok(MatchRecognizeQuantifiedPattern {
10543 inner: inner__,
10544 quantifier: quantifier__,
10545 reluctant: reluctant__.unwrap_or_default(),
10546 })
10547 }
10548 }
10549 deserializer.deserialize_struct("stream_plan.MatchRecognizeQuantifiedPattern", FIELDS, GeneratedVisitor)
10550 }
10551}
10552impl serde::Serialize for MatchRecognizeQuantifier {
10553 #[allow(deprecated)]
10554 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10555 where
10556 S: serde::Serializer,
10557 {
10558 use serde::ser::SerializeStruct;
10559 let mut len = 0;
10560 if self.kind != 0 {
10561 len += 1;
10562 }
10563 if self.min != 0 {
10564 len += 1;
10565 }
10566 if self.max.is_some() {
10567 len += 1;
10568 }
10569 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeQuantifier", len)?;
10570 if self.kind != 0 {
10571 let v = match_recognize_quantifier::Kind::try_from(self.kind)
10572 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
10573 struct_ser.serialize_field("kind", &v)?;
10574 }
10575 if self.min != 0 {
10576 struct_ser.serialize_field("min", &self.min)?;
10577 }
10578 if let Some(v) = self.max.as_ref() {
10579 struct_ser.serialize_field("max", v)?;
10580 }
10581 struct_ser.end()
10582 }
10583}
10584impl<'de> serde::Deserialize<'de> for MatchRecognizeQuantifier {
10585 #[allow(deprecated)]
10586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10587 where
10588 D: serde::Deserializer<'de>,
10589 {
10590 const FIELDS: &[&str] = &[
10591 "kind",
10592 "min",
10593 "max",
10594 ];
10595
10596 #[allow(clippy::enum_variant_names)]
10597 enum GeneratedField {
10598 Kind,
10599 Min,
10600 Max,
10601 }
10602 impl<'de> serde::Deserialize<'de> for GeneratedField {
10603 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10604 where
10605 D: serde::Deserializer<'de>,
10606 {
10607 struct GeneratedVisitor;
10608
10609 impl serde::de::Visitor<'_> for GeneratedVisitor {
10610 type Value = GeneratedField;
10611
10612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10613 write!(formatter, "expected one of: {:?}", &FIELDS)
10614 }
10615
10616 #[allow(unused_variables)]
10617 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10618 where
10619 E: serde::de::Error,
10620 {
10621 match value {
10622 "kind" => Ok(GeneratedField::Kind),
10623 "min" => Ok(GeneratedField::Min),
10624 "max" => Ok(GeneratedField::Max),
10625 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10626 }
10627 }
10628 }
10629 deserializer.deserialize_identifier(GeneratedVisitor)
10630 }
10631 }
10632 struct GeneratedVisitor;
10633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10634 type Value = MatchRecognizeQuantifier;
10635
10636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10637 formatter.write_str("struct stream_plan.MatchRecognizeQuantifier")
10638 }
10639
10640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeQuantifier, V::Error>
10641 where
10642 V: serde::de::MapAccess<'de>,
10643 {
10644 let mut kind__ = None;
10645 let mut min__ = None;
10646 let mut max__ = None;
10647 while let Some(k) = map_.next_key()? {
10648 match k {
10649 GeneratedField::Kind => {
10650 if kind__.is_some() {
10651 return Err(serde::de::Error::duplicate_field("kind"));
10652 }
10653 kind__ = Some(map_.next_value::<match_recognize_quantifier::Kind>()? as i32);
10654 }
10655 GeneratedField::Min => {
10656 if min__.is_some() {
10657 return Err(serde::de::Error::duplicate_field("min"));
10658 }
10659 min__ =
10660 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10661 ;
10662 }
10663 GeneratedField::Max => {
10664 if max__.is_some() {
10665 return Err(serde::de::Error::duplicate_field("max"));
10666 }
10667 max__ =
10668 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10669 ;
10670 }
10671 }
10672 }
10673 Ok(MatchRecognizeQuantifier {
10674 kind: kind__.unwrap_or_default(),
10675 min: min__.unwrap_or_default(),
10676 max: max__,
10677 })
10678 }
10679 }
10680 deserializer.deserialize_struct("stream_plan.MatchRecognizeQuantifier", FIELDS, GeneratedVisitor)
10681 }
10682}
10683impl serde::Serialize for match_recognize_quantifier::Kind {
10684 #[allow(deprecated)]
10685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10686 where
10687 S: serde::Serializer,
10688 {
10689 let variant = match self {
10690 Self::Unspecified => "KIND_UNSPECIFIED",
10691 Self::Star => "KIND_STAR",
10692 Self::Plus => "KIND_PLUS",
10693 Self::Question => "KIND_QUESTION",
10694 Self::Range => "KIND_RANGE",
10695 };
10696 serializer.serialize_str(variant)
10697 }
10698}
10699impl<'de> serde::Deserialize<'de> for match_recognize_quantifier::Kind {
10700 #[allow(deprecated)]
10701 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10702 where
10703 D: serde::Deserializer<'de>,
10704 {
10705 const FIELDS: &[&str] = &[
10706 "KIND_UNSPECIFIED",
10707 "KIND_STAR",
10708 "KIND_PLUS",
10709 "KIND_QUESTION",
10710 "KIND_RANGE",
10711 ];
10712
10713 struct GeneratedVisitor;
10714
10715 impl serde::de::Visitor<'_> for GeneratedVisitor {
10716 type Value = match_recognize_quantifier::Kind;
10717
10718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10719 write!(formatter, "expected one of: {:?}", &FIELDS)
10720 }
10721
10722 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10723 where
10724 E: serde::de::Error,
10725 {
10726 i32::try_from(v)
10727 .ok()
10728 .and_then(|x| x.try_into().ok())
10729 .ok_or_else(|| {
10730 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10731 })
10732 }
10733
10734 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10735 where
10736 E: serde::de::Error,
10737 {
10738 i32::try_from(v)
10739 .ok()
10740 .and_then(|x| x.try_into().ok())
10741 .ok_or_else(|| {
10742 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10743 })
10744 }
10745
10746 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10747 where
10748 E: serde::de::Error,
10749 {
10750 match value {
10751 "KIND_UNSPECIFIED" => Ok(match_recognize_quantifier::Kind::Unspecified),
10752 "KIND_STAR" => Ok(match_recognize_quantifier::Kind::Star),
10753 "KIND_PLUS" => Ok(match_recognize_quantifier::Kind::Plus),
10754 "KIND_QUESTION" => Ok(match_recognize_quantifier::Kind::Question),
10755 "KIND_RANGE" => Ok(match_recognize_quantifier::Kind::Range),
10756 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10757 }
10758 }
10759 }
10760 deserializer.deserialize_any(GeneratedVisitor)
10761 }
10762}
10763impl serde::Serialize for MaterializeNode {
10764 #[allow(deprecated)]
10765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10766 where
10767 S: serde::Serializer,
10768 {
10769 use serde::ser::SerializeStruct;
10770 let mut len = 0;
10771 if self.table_id != 0 {
10772 len += 1;
10773 }
10774 if !self.column_orders.is_empty() {
10775 len += 1;
10776 }
10777 if self.table.is_some() {
10778 len += 1;
10779 }
10780 if self.staging_table.is_some() {
10781 len += 1;
10782 }
10783 if self.refresh_progress_table.is_some() {
10784 len += 1;
10785 }
10786 if self.cleaned_by_ttl_watermark {
10787 len += 1;
10788 }
10789 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
10790 if self.table_id != 0 {
10791 struct_ser.serialize_field("tableId", &self.table_id)?;
10792 }
10793 if !self.column_orders.is_empty() {
10794 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
10795 }
10796 if let Some(v) = self.table.as_ref() {
10797 struct_ser.serialize_field("table", v)?;
10798 }
10799 if let Some(v) = self.staging_table.as_ref() {
10800 struct_ser.serialize_field("stagingTable", v)?;
10801 }
10802 if let Some(v) = self.refresh_progress_table.as_ref() {
10803 struct_ser.serialize_field("refreshProgressTable", v)?;
10804 }
10805 if self.cleaned_by_ttl_watermark {
10806 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
10807 }
10808 struct_ser.end()
10809 }
10810}
10811impl<'de> serde::Deserialize<'de> for MaterializeNode {
10812 #[allow(deprecated)]
10813 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10814 where
10815 D: serde::Deserializer<'de>,
10816 {
10817 const FIELDS: &[&str] = &[
10818 "table_id",
10819 "tableId",
10820 "column_orders",
10821 "columnOrders",
10822 "table",
10823 "staging_table",
10824 "stagingTable",
10825 "refresh_progress_table",
10826 "refreshProgressTable",
10827 "cleaned_by_ttl_watermark",
10828 "cleanedByTtlWatermark",
10829 ];
10830
10831 #[allow(clippy::enum_variant_names)]
10832 enum GeneratedField {
10833 TableId,
10834 ColumnOrders,
10835 Table,
10836 StagingTable,
10837 RefreshProgressTable,
10838 CleanedByTtlWatermark,
10839 }
10840 impl<'de> serde::Deserialize<'de> for GeneratedField {
10841 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10842 where
10843 D: serde::Deserializer<'de>,
10844 {
10845 struct GeneratedVisitor;
10846
10847 impl serde::de::Visitor<'_> for GeneratedVisitor {
10848 type Value = GeneratedField;
10849
10850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10851 write!(formatter, "expected one of: {:?}", &FIELDS)
10852 }
10853
10854 #[allow(unused_variables)]
10855 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10856 where
10857 E: serde::de::Error,
10858 {
10859 match value {
10860 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10861 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
10862 "table" => Ok(GeneratedField::Table),
10863 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
10864 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
10865 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
10866 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10867 }
10868 }
10869 }
10870 deserializer.deserialize_identifier(GeneratedVisitor)
10871 }
10872 }
10873 struct GeneratedVisitor;
10874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10875 type Value = MaterializeNode;
10876
10877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10878 formatter.write_str("struct stream_plan.MaterializeNode")
10879 }
10880
10881 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
10882 where
10883 V: serde::de::MapAccess<'de>,
10884 {
10885 let mut table_id__ = None;
10886 let mut column_orders__ = None;
10887 let mut table__ = None;
10888 let mut staging_table__ = None;
10889 let mut refresh_progress_table__ = None;
10890 let mut cleaned_by_ttl_watermark__ = None;
10891 while let Some(k) = map_.next_key()? {
10892 match k {
10893 GeneratedField::TableId => {
10894 if table_id__.is_some() {
10895 return Err(serde::de::Error::duplicate_field("tableId"));
10896 }
10897 table_id__ =
10898 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10899 ;
10900 }
10901 GeneratedField::ColumnOrders => {
10902 if column_orders__.is_some() {
10903 return Err(serde::de::Error::duplicate_field("columnOrders"));
10904 }
10905 column_orders__ = Some(map_.next_value()?);
10906 }
10907 GeneratedField::Table => {
10908 if table__.is_some() {
10909 return Err(serde::de::Error::duplicate_field("table"));
10910 }
10911 table__ = map_.next_value()?;
10912 }
10913 GeneratedField::StagingTable => {
10914 if staging_table__.is_some() {
10915 return Err(serde::de::Error::duplicate_field("stagingTable"));
10916 }
10917 staging_table__ = map_.next_value()?;
10918 }
10919 GeneratedField::RefreshProgressTable => {
10920 if refresh_progress_table__.is_some() {
10921 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
10922 }
10923 refresh_progress_table__ = map_.next_value()?;
10924 }
10925 GeneratedField::CleanedByTtlWatermark => {
10926 if cleaned_by_ttl_watermark__.is_some() {
10927 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
10928 }
10929 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
10930 }
10931 }
10932 }
10933 Ok(MaterializeNode {
10934 table_id: table_id__.unwrap_or_default(),
10935 column_orders: column_orders__.unwrap_or_default(),
10936 table: table__,
10937 staging_table: staging_table__,
10938 refresh_progress_table: refresh_progress_table__,
10939 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
10940 })
10941 }
10942 }
10943 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
10944 }
10945}
10946impl serde::Serialize for MaterializedExprsNode {
10947 #[allow(deprecated)]
10948 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10949 where
10950 S: serde::Serializer,
10951 {
10952 use serde::ser::SerializeStruct;
10953 let mut len = 0;
10954 if !self.exprs.is_empty() {
10955 len += 1;
10956 }
10957 if self.state_table.is_some() {
10958 len += 1;
10959 }
10960 if self.state_clean_col_idx.is_some() {
10961 len += 1;
10962 }
10963 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
10964 if !self.exprs.is_empty() {
10965 struct_ser.serialize_field("exprs", &self.exprs)?;
10966 }
10967 if let Some(v) = self.state_table.as_ref() {
10968 struct_ser.serialize_field("stateTable", v)?;
10969 }
10970 if let Some(v) = self.state_clean_col_idx.as_ref() {
10971 struct_ser.serialize_field("stateCleanColIdx", v)?;
10972 }
10973 struct_ser.end()
10974 }
10975}
10976impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
10977 #[allow(deprecated)]
10978 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10979 where
10980 D: serde::Deserializer<'de>,
10981 {
10982 const FIELDS: &[&str] = &[
10983 "exprs",
10984 "state_table",
10985 "stateTable",
10986 "state_clean_col_idx",
10987 "stateCleanColIdx",
10988 ];
10989
10990 #[allow(clippy::enum_variant_names)]
10991 enum GeneratedField {
10992 Exprs,
10993 StateTable,
10994 StateCleanColIdx,
10995 }
10996 impl<'de> serde::Deserialize<'de> for GeneratedField {
10997 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10998 where
10999 D: serde::Deserializer<'de>,
11000 {
11001 struct GeneratedVisitor;
11002
11003 impl serde::de::Visitor<'_> for GeneratedVisitor {
11004 type Value = GeneratedField;
11005
11006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11007 write!(formatter, "expected one of: {:?}", &FIELDS)
11008 }
11009
11010 #[allow(unused_variables)]
11011 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11012 where
11013 E: serde::de::Error,
11014 {
11015 match value {
11016 "exprs" => Ok(GeneratedField::Exprs),
11017 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11018 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
11019 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11020 }
11021 }
11022 }
11023 deserializer.deserialize_identifier(GeneratedVisitor)
11024 }
11025 }
11026 struct GeneratedVisitor;
11027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11028 type Value = MaterializedExprsNode;
11029
11030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11031 formatter.write_str("struct stream_plan.MaterializedExprsNode")
11032 }
11033
11034 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
11035 where
11036 V: serde::de::MapAccess<'de>,
11037 {
11038 let mut exprs__ = None;
11039 let mut state_table__ = None;
11040 let mut state_clean_col_idx__ = None;
11041 while let Some(k) = map_.next_key()? {
11042 match k {
11043 GeneratedField::Exprs => {
11044 if exprs__.is_some() {
11045 return Err(serde::de::Error::duplicate_field("exprs"));
11046 }
11047 exprs__ = Some(map_.next_value()?);
11048 }
11049 GeneratedField::StateTable => {
11050 if state_table__.is_some() {
11051 return Err(serde::de::Error::duplicate_field("stateTable"));
11052 }
11053 state_table__ = map_.next_value()?;
11054 }
11055 GeneratedField::StateCleanColIdx => {
11056 if state_clean_col_idx__.is_some() {
11057 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
11058 }
11059 state_clean_col_idx__ =
11060 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11061 ;
11062 }
11063 }
11064 }
11065 Ok(MaterializedExprsNode {
11066 exprs: exprs__.unwrap_or_default(),
11067 state_table: state_table__,
11068 state_clean_col_idx: state_clean_col_idx__,
11069 })
11070 }
11071 }
11072 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
11073 }
11074}
11075impl serde::Serialize for MergeNode {
11076 #[allow(deprecated)]
11077 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11078 where
11079 S: serde::Serializer,
11080 {
11081 use serde::ser::SerializeStruct;
11082 let mut len = 0;
11083 if !self.upstream_actor_id.is_empty() {
11084 len += 1;
11085 }
11086 if self.upstream_fragment_id != 0 {
11087 len += 1;
11088 }
11089 if self.upstream_dispatcher_type != 0 {
11090 len += 1;
11091 }
11092 if !self.fields.is_empty() {
11093 len += 1;
11094 }
11095 if self.allow_empty_upstream {
11096 len += 1;
11097 }
11098 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
11099 if !self.upstream_actor_id.is_empty() {
11100 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
11101 }
11102 if self.upstream_fragment_id != 0 {
11103 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
11104 }
11105 if self.upstream_dispatcher_type != 0 {
11106 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
11107 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
11108 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
11109 }
11110 if !self.fields.is_empty() {
11111 struct_ser.serialize_field("fields", &self.fields)?;
11112 }
11113 if self.allow_empty_upstream {
11114 struct_ser.serialize_field("allowEmptyUpstream", &self.allow_empty_upstream)?;
11115 }
11116 struct_ser.end()
11117 }
11118}
11119impl<'de> serde::Deserialize<'de> for MergeNode {
11120 #[allow(deprecated)]
11121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11122 where
11123 D: serde::Deserializer<'de>,
11124 {
11125 const FIELDS: &[&str] = &[
11126 "upstream_actor_id",
11127 "upstreamActorId",
11128 "upstream_fragment_id",
11129 "upstreamFragmentId",
11130 "upstream_dispatcher_type",
11131 "upstreamDispatcherType",
11132 "fields",
11133 "allow_empty_upstream",
11134 "allowEmptyUpstream",
11135 ];
11136
11137 #[allow(clippy::enum_variant_names)]
11138 enum GeneratedField {
11139 UpstreamActorId,
11140 UpstreamFragmentId,
11141 UpstreamDispatcherType,
11142 Fields,
11143 AllowEmptyUpstream,
11144 }
11145 impl<'de> serde::Deserialize<'de> for GeneratedField {
11146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11147 where
11148 D: serde::Deserializer<'de>,
11149 {
11150 struct GeneratedVisitor;
11151
11152 impl serde::de::Visitor<'_> for GeneratedVisitor {
11153 type Value = GeneratedField;
11154
11155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11156 write!(formatter, "expected one of: {:?}", &FIELDS)
11157 }
11158
11159 #[allow(unused_variables)]
11160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11161 where
11162 E: serde::de::Error,
11163 {
11164 match value {
11165 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
11166 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
11167 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
11168 "fields" => Ok(GeneratedField::Fields),
11169 "allowEmptyUpstream" | "allow_empty_upstream" => Ok(GeneratedField::AllowEmptyUpstream),
11170 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11171 }
11172 }
11173 }
11174 deserializer.deserialize_identifier(GeneratedVisitor)
11175 }
11176 }
11177 struct GeneratedVisitor;
11178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11179 type Value = MergeNode;
11180
11181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11182 formatter.write_str("struct stream_plan.MergeNode")
11183 }
11184
11185 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
11186 where
11187 V: serde::de::MapAccess<'de>,
11188 {
11189 let mut upstream_actor_id__ = None;
11190 let mut upstream_fragment_id__ = None;
11191 let mut upstream_dispatcher_type__ = None;
11192 let mut fields__ = None;
11193 let mut allow_empty_upstream__ = None;
11194 while let Some(k) = map_.next_key()? {
11195 match k {
11196 GeneratedField::UpstreamActorId => {
11197 if upstream_actor_id__.is_some() {
11198 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
11199 }
11200 upstream_actor_id__ =
11201 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11202 .into_iter().map(|x| x.0).collect())
11203 ;
11204 }
11205 GeneratedField::UpstreamFragmentId => {
11206 if upstream_fragment_id__.is_some() {
11207 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
11208 }
11209 upstream_fragment_id__ =
11210 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11211 ;
11212 }
11213 GeneratedField::UpstreamDispatcherType => {
11214 if upstream_dispatcher_type__.is_some() {
11215 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
11216 }
11217 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
11218 }
11219 GeneratedField::Fields => {
11220 if fields__.is_some() {
11221 return Err(serde::de::Error::duplicate_field("fields"));
11222 }
11223 fields__ = Some(map_.next_value()?);
11224 }
11225 GeneratedField::AllowEmptyUpstream => {
11226 if allow_empty_upstream__.is_some() {
11227 return Err(serde::de::Error::duplicate_field("allowEmptyUpstream"));
11228 }
11229 allow_empty_upstream__ = Some(map_.next_value()?);
11230 }
11231 }
11232 }
11233 Ok(MergeNode {
11234 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
11235 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
11236 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
11237 fields: fields__.unwrap_or_default(),
11238 allow_empty_upstream: allow_empty_upstream__.unwrap_or_default(),
11239 })
11240 }
11241 }
11242 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
11243 }
11244}
11245impl serde::Serialize for NoOpNode {
11246 #[allow(deprecated)]
11247 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11248 where
11249 S: serde::Serializer,
11250 {
11251 use serde::ser::SerializeStruct;
11252 let len = 0;
11253 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
11254 struct_ser.end()
11255 }
11256}
11257impl<'de> serde::Deserialize<'de> for NoOpNode {
11258 #[allow(deprecated)]
11259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11260 where
11261 D: serde::Deserializer<'de>,
11262 {
11263 const FIELDS: &[&str] = &[
11264 ];
11265
11266 #[allow(clippy::enum_variant_names)]
11267 enum GeneratedField {
11268 }
11269 impl<'de> serde::Deserialize<'de> for GeneratedField {
11270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11271 where
11272 D: serde::Deserializer<'de>,
11273 {
11274 struct GeneratedVisitor;
11275
11276 impl serde::de::Visitor<'_> for GeneratedVisitor {
11277 type Value = GeneratedField;
11278
11279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11280 write!(formatter, "expected one of: {:?}", &FIELDS)
11281 }
11282
11283 #[allow(unused_variables)]
11284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11285 where
11286 E: serde::de::Error,
11287 {
11288 Err(serde::de::Error::unknown_field(value, FIELDS))
11289 }
11290 }
11291 deserializer.deserialize_identifier(GeneratedVisitor)
11292 }
11293 }
11294 struct GeneratedVisitor;
11295 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11296 type Value = NoOpNode;
11297
11298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11299 formatter.write_str("struct stream_plan.NoOpNode")
11300 }
11301
11302 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
11303 where
11304 V: serde::de::MapAccess<'de>,
11305 {
11306 while map_.next_key::<GeneratedField>()?.is_some() {
11307 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11308 }
11309 Ok(NoOpNode {
11310 })
11311 }
11312 }
11313 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
11314 }
11315}
11316impl serde::Serialize for NowModeGenerateSeries {
11317 #[allow(deprecated)]
11318 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11319 where
11320 S: serde::Serializer,
11321 {
11322 use serde::ser::SerializeStruct;
11323 let mut len = 0;
11324 if self.start_timestamp.is_some() {
11325 len += 1;
11326 }
11327 if self.interval.is_some() {
11328 len += 1;
11329 }
11330 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
11331 if let Some(v) = self.start_timestamp.as_ref() {
11332 struct_ser.serialize_field("startTimestamp", v)?;
11333 }
11334 if let Some(v) = self.interval.as_ref() {
11335 struct_ser.serialize_field("interval", v)?;
11336 }
11337 struct_ser.end()
11338 }
11339}
11340impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
11341 #[allow(deprecated)]
11342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11343 where
11344 D: serde::Deserializer<'de>,
11345 {
11346 const FIELDS: &[&str] = &[
11347 "start_timestamp",
11348 "startTimestamp",
11349 "interval",
11350 ];
11351
11352 #[allow(clippy::enum_variant_names)]
11353 enum GeneratedField {
11354 StartTimestamp,
11355 Interval,
11356 }
11357 impl<'de> serde::Deserialize<'de> for GeneratedField {
11358 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11359 where
11360 D: serde::Deserializer<'de>,
11361 {
11362 struct GeneratedVisitor;
11363
11364 impl serde::de::Visitor<'_> for GeneratedVisitor {
11365 type Value = GeneratedField;
11366
11367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11368 write!(formatter, "expected one of: {:?}", &FIELDS)
11369 }
11370
11371 #[allow(unused_variables)]
11372 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11373 where
11374 E: serde::de::Error,
11375 {
11376 match value {
11377 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
11378 "interval" => Ok(GeneratedField::Interval),
11379 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11380 }
11381 }
11382 }
11383 deserializer.deserialize_identifier(GeneratedVisitor)
11384 }
11385 }
11386 struct GeneratedVisitor;
11387 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11388 type Value = NowModeGenerateSeries;
11389
11390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11391 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
11392 }
11393
11394 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
11395 where
11396 V: serde::de::MapAccess<'de>,
11397 {
11398 let mut start_timestamp__ = None;
11399 let mut interval__ = None;
11400 while let Some(k) = map_.next_key()? {
11401 match k {
11402 GeneratedField::StartTimestamp => {
11403 if start_timestamp__.is_some() {
11404 return Err(serde::de::Error::duplicate_field("startTimestamp"));
11405 }
11406 start_timestamp__ = map_.next_value()?;
11407 }
11408 GeneratedField::Interval => {
11409 if interval__.is_some() {
11410 return Err(serde::de::Error::duplicate_field("interval"));
11411 }
11412 interval__ = map_.next_value()?;
11413 }
11414 }
11415 }
11416 Ok(NowModeGenerateSeries {
11417 start_timestamp: start_timestamp__,
11418 interval: interval__,
11419 })
11420 }
11421 }
11422 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
11423 }
11424}
11425impl serde::Serialize for NowModeUpdateCurrent {
11426 #[allow(deprecated)]
11427 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11428 where
11429 S: serde::Serializer,
11430 {
11431 use serde::ser::SerializeStruct;
11432 let len = 0;
11433 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
11434 struct_ser.end()
11435 }
11436}
11437impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
11438 #[allow(deprecated)]
11439 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11440 where
11441 D: serde::Deserializer<'de>,
11442 {
11443 const FIELDS: &[&str] = &[
11444 ];
11445
11446 #[allow(clippy::enum_variant_names)]
11447 enum GeneratedField {
11448 }
11449 impl<'de> serde::Deserialize<'de> for GeneratedField {
11450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11451 where
11452 D: serde::Deserializer<'de>,
11453 {
11454 struct GeneratedVisitor;
11455
11456 impl serde::de::Visitor<'_> for GeneratedVisitor {
11457 type Value = GeneratedField;
11458
11459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11460 write!(formatter, "expected one of: {:?}", &FIELDS)
11461 }
11462
11463 #[allow(unused_variables)]
11464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11465 where
11466 E: serde::de::Error,
11467 {
11468 Err(serde::de::Error::unknown_field(value, FIELDS))
11469 }
11470 }
11471 deserializer.deserialize_identifier(GeneratedVisitor)
11472 }
11473 }
11474 struct GeneratedVisitor;
11475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11476 type Value = NowModeUpdateCurrent;
11477
11478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11479 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
11480 }
11481
11482 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
11483 where
11484 V: serde::de::MapAccess<'de>,
11485 {
11486 while map_.next_key::<GeneratedField>()?.is_some() {
11487 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11488 }
11489 Ok(NowModeUpdateCurrent {
11490 })
11491 }
11492 }
11493 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
11494 }
11495}
11496impl serde::Serialize for NowNode {
11497 #[allow(deprecated)]
11498 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11499 where
11500 S: serde::Serializer,
11501 {
11502 use serde::ser::SerializeStruct;
11503 let mut len = 0;
11504 if self.state_table.is_some() {
11505 len += 1;
11506 }
11507 if self.mode.is_some() {
11508 len += 1;
11509 }
11510 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
11511 if let Some(v) = self.state_table.as_ref() {
11512 struct_ser.serialize_field("stateTable", v)?;
11513 }
11514 if let Some(v) = self.mode.as_ref() {
11515 match v {
11516 now_node::Mode::UpdateCurrent(v) => {
11517 struct_ser.serialize_field("updateCurrent", v)?;
11518 }
11519 now_node::Mode::GenerateSeries(v) => {
11520 struct_ser.serialize_field("generateSeries", v)?;
11521 }
11522 }
11523 }
11524 struct_ser.end()
11525 }
11526}
11527impl<'de> serde::Deserialize<'de> for NowNode {
11528 #[allow(deprecated)]
11529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11530 where
11531 D: serde::Deserializer<'de>,
11532 {
11533 const FIELDS: &[&str] = &[
11534 "state_table",
11535 "stateTable",
11536 "update_current",
11537 "updateCurrent",
11538 "generate_series",
11539 "generateSeries",
11540 ];
11541
11542 #[allow(clippy::enum_variant_names)]
11543 enum GeneratedField {
11544 StateTable,
11545 UpdateCurrent,
11546 GenerateSeries,
11547 }
11548 impl<'de> serde::Deserialize<'de> for GeneratedField {
11549 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11550 where
11551 D: serde::Deserializer<'de>,
11552 {
11553 struct GeneratedVisitor;
11554
11555 impl serde::de::Visitor<'_> for GeneratedVisitor {
11556 type Value = GeneratedField;
11557
11558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11559 write!(formatter, "expected one of: {:?}", &FIELDS)
11560 }
11561
11562 #[allow(unused_variables)]
11563 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11564 where
11565 E: serde::de::Error,
11566 {
11567 match value {
11568 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11569 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
11570 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
11571 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11572 }
11573 }
11574 }
11575 deserializer.deserialize_identifier(GeneratedVisitor)
11576 }
11577 }
11578 struct GeneratedVisitor;
11579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11580 type Value = NowNode;
11581
11582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11583 formatter.write_str("struct stream_plan.NowNode")
11584 }
11585
11586 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
11587 where
11588 V: serde::de::MapAccess<'de>,
11589 {
11590 let mut state_table__ = None;
11591 let mut mode__ = None;
11592 while let Some(k) = map_.next_key()? {
11593 match k {
11594 GeneratedField::StateTable => {
11595 if state_table__.is_some() {
11596 return Err(serde::de::Error::duplicate_field("stateTable"));
11597 }
11598 state_table__ = map_.next_value()?;
11599 }
11600 GeneratedField::UpdateCurrent => {
11601 if mode__.is_some() {
11602 return Err(serde::de::Error::duplicate_field("updateCurrent"));
11603 }
11604 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
11605;
11606 }
11607 GeneratedField::GenerateSeries => {
11608 if mode__.is_some() {
11609 return Err(serde::de::Error::duplicate_field("generateSeries"));
11610 }
11611 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
11612;
11613 }
11614 }
11615 }
11616 Ok(NowNode {
11617 state_table: state_table__,
11618 mode: mode__,
11619 })
11620 }
11621 }
11622 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
11623 }
11624}
11625impl serde::Serialize for OverWindowCachePolicy {
11626 #[allow(deprecated)]
11627 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11628 where
11629 S: serde::Serializer,
11630 {
11631 let variant = match self {
11632 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
11633 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
11634 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
11635 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
11636 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
11637 };
11638 serializer.serialize_str(variant)
11639 }
11640}
11641impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
11642 #[allow(deprecated)]
11643 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11644 where
11645 D: serde::Deserializer<'de>,
11646 {
11647 const FIELDS: &[&str] = &[
11648 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
11649 "OVER_WINDOW_CACHE_POLICY_FULL",
11650 "OVER_WINDOW_CACHE_POLICY_RECENT",
11651 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
11652 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
11653 ];
11654
11655 struct GeneratedVisitor;
11656
11657 impl serde::de::Visitor<'_> for GeneratedVisitor {
11658 type Value = OverWindowCachePolicy;
11659
11660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11661 write!(formatter, "expected one of: {:?}", &FIELDS)
11662 }
11663
11664 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11665 where
11666 E: serde::de::Error,
11667 {
11668 i32::try_from(v)
11669 .ok()
11670 .and_then(|x| x.try_into().ok())
11671 .ok_or_else(|| {
11672 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11673 })
11674 }
11675
11676 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11677 where
11678 E: serde::de::Error,
11679 {
11680 i32::try_from(v)
11681 .ok()
11682 .and_then(|x| x.try_into().ok())
11683 .ok_or_else(|| {
11684 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11685 })
11686 }
11687
11688 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11689 where
11690 E: serde::de::Error,
11691 {
11692 match value {
11693 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
11694 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
11695 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
11696 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
11697 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
11698 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11699 }
11700 }
11701 }
11702 deserializer.deserialize_any(GeneratedVisitor)
11703 }
11704}
11705impl serde::Serialize for OverWindowNode {
11706 #[allow(deprecated)]
11707 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11708 where
11709 S: serde::Serializer,
11710 {
11711 use serde::ser::SerializeStruct;
11712 let mut len = 0;
11713 if !self.calls.is_empty() {
11714 len += 1;
11715 }
11716 if !self.partition_by.is_empty() {
11717 len += 1;
11718 }
11719 if !self.order_by.is_empty() {
11720 len += 1;
11721 }
11722 if self.state_table.is_some() {
11723 len += 1;
11724 }
11725 if self.cache_policy != 0 {
11726 len += 1;
11727 }
11728 if self.enable_state_cleaning {
11729 len += 1;
11730 }
11731 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
11732 if !self.calls.is_empty() {
11733 struct_ser.serialize_field("calls", &self.calls)?;
11734 }
11735 if !self.partition_by.is_empty() {
11736 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
11737 }
11738 if !self.order_by.is_empty() {
11739 struct_ser.serialize_field("orderBy", &self.order_by)?;
11740 }
11741 if let Some(v) = self.state_table.as_ref() {
11742 struct_ser.serialize_field("stateTable", v)?;
11743 }
11744 if self.cache_policy != 0 {
11745 let v = OverWindowCachePolicy::try_from(self.cache_policy)
11746 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
11747 struct_ser.serialize_field("cachePolicy", &v)?;
11748 }
11749 if self.enable_state_cleaning {
11750 struct_ser.serialize_field("enableStateCleaning", &self.enable_state_cleaning)?;
11751 }
11752 struct_ser.end()
11753 }
11754}
11755impl<'de> serde::Deserialize<'de> for OverWindowNode {
11756 #[allow(deprecated)]
11757 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11758 where
11759 D: serde::Deserializer<'de>,
11760 {
11761 const FIELDS: &[&str] = &[
11762 "calls",
11763 "partition_by",
11764 "partitionBy",
11765 "order_by",
11766 "orderBy",
11767 "state_table",
11768 "stateTable",
11769 "cache_policy",
11770 "cachePolicy",
11771 "enable_state_cleaning",
11772 "enableStateCleaning",
11773 ];
11774
11775 #[allow(clippy::enum_variant_names)]
11776 enum GeneratedField {
11777 Calls,
11778 PartitionBy,
11779 OrderBy,
11780 StateTable,
11781 CachePolicy,
11782 EnableStateCleaning,
11783 }
11784 impl<'de> serde::Deserialize<'de> for GeneratedField {
11785 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11786 where
11787 D: serde::Deserializer<'de>,
11788 {
11789 struct GeneratedVisitor;
11790
11791 impl serde::de::Visitor<'_> for GeneratedVisitor {
11792 type Value = GeneratedField;
11793
11794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11795 write!(formatter, "expected one of: {:?}", &FIELDS)
11796 }
11797
11798 #[allow(unused_variables)]
11799 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11800 where
11801 E: serde::de::Error,
11802 {
11803 match value {
11804 "calls" => Ok(GeneratedField::Calls),
11805 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
11806 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
11807 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11808 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
11809 "enableStateCleaning" | "enable_state_cleaning" => Ok(GeneratedField::EnableStateCleaning),
11810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11811 }
11812 }
11813 }
11814 deserializer.deserialize_identifier(GeneratedVisitor)
11815 }
11816 }
11817 struct GeneratedVisitor;
11818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11819 type Value = OverWindowNode;
11820
11821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11822 formatter.write_str("struct stream_plan.OverWindowNode")
11823 }
11824
11825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
11826 where
11827 V: serde::de::MapAccess<'de>,
11828 {
11829 let mut calls__ = None;
11830 let mut partition_by__ = None;
11831 let mut order_by__ = None;
11832 let mut state_table__ = None;
11833 let mut cache_policy__ = None;
11834 let mut enable_state_cleaning__ = None;
11835 while let Some(k) = map_.next_key()? {
11836 match k {
11837 GeneratedField::Calls => {
11838 if calls__.is_some() {
11839 return Err(serde::de::Error::duplicate_field("calls"));
11840 }
11841 calls__ = Some(map_.next_value()?);
11842 }
11843 GeneratedField::PartitionBy => {
11844 if partition_by__.is_some() {
11845 return Err(serde::de::Error::duplicate_field("partitionBy"));
11846 }
11847 partition_by__ =
11848 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11849 .into_iter().map(|x| x.0).collect())
11850 ;
11851 }
11852 GeneratedField::OrderBy => {
11853 if order_by__.is_some() {
11854 return Err(serde::de::Error::duplicate_field("orderBy"));
11855 }
11856 order_by__ = Some(map_.next_value()?);
11857 }
11858 GeneratedField::StateTable => {
11859 if state_table__.is_some() {
11860 return Err(serde::de::Error::duplicate_field("stateTable"));
11861 }
11862 state_table__ = map_.next_value()?;
11863 }
11864 GeneratedField::CachePolicy => {
11865 if cache_policy__.is_some() {
11866 return Err(serde::de::Error::duplicate_field("cachePolicy"));
11867 }
11868 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
11869 }
11870 GeneratedField::EnableStateCleaning => {
11871 if enable_state_cleaning__.is_some() {
11872 return Err(serde::de::Error::duplicate_field("enableStateCleaning"));
11873 }
11874 enable_state_cleaning__ = Some(map_.next_value()?);
11875 }
11876 }
11877 }
11878 Ok(OverWindowNode {
11879 calls: calls__.unwrap_or_default(),
11880 partition_by: partition_by__.unwrap_or_default(),
11881 order_by: order_by__.unwrap_or_default(),
11882 state_table: state_table__,
11883 cache_policy: cache_policy__.unwrap_or_default(),
11884 enable_state_cleaning: enable_state_cleaning__.unwrap_or_default(),
11885 })
11886 }
11887 }
11888 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
11889 }
11890}
11891impl serde::Serialize for PauseMutation {
11892 #[allow(deprecated)]
11893 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11894 where
11895 S: serde::Serializer,
11896 {
11897 use serde::ser::SerializeStruct;
11898 let len = 0;
11899 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
11900 struct_ser.end()
11901 }
11902}
11903impl<'de> serde::Deserialize<'de> for PauseMutation {
11904 #[allow(deprecated)]
11905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11906 where
11907 D: serde::Deserializer<'de>,
11908 {
11909 const FIELDS: &[&str] = &[
11910 ];
11911
11912 #[allow(clippy::enum_variant_names)]
11913 enum GeneratedField {
11914 }
11915 impl<'de> serde::Deserialize<'de> for GeneratedField {
11916 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11917 where
11918 D: serde::Deserializer<'de>,
11919 {
11920 struct GeneratedVisitor;
11921
11922 impl serde::de::Visitor<'_> for GeneratedVisitor {
11923 type Value = GeneratedField;
11924
11925 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11926 write!(formatter, "expected one of: {:?}", &FIELDS)
11927 }
11928
11929 #[allow(unused_variables)]
11930 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11931 where
11932 E: serde::de::Error,
11933 {
11934 Err(serde::de::Error::unknown_field(value, FIELDS))
11935 }
11936 }
11937 deserializer.deserialize_identifier(GeneratedVisitor)
11938 }
11939 }
11940 struct GeneratedVisitor;
11941 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11942 type Value = PauseMutation;
11943
11944 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11945 formatter.write_str("struct stream_plan.PauseMutation")
11946 }
11947
11948 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
11949 where
11950 V: serde::de::MapAccess<'de>,
11951 {
11952 while map_.next_key::<GeneratedField>()?.is_some() {
11953 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11954 }
11955 Ok(PauseMutation {
11956 })
11957 }
11958 }
11959 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
11960 }
11961}
11962impl serde::Serialize for ProjectNode {
11963 #[allow(deprecated)]
11964 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11965 where
11966 S: serde::Serializer,
11967 {
11968 use serde::ser::SerializeStruct;
11969 let mut len = 0;
11970 if !self.select_list.is_empty() {
11971 len += 1;
11972 }
11973 if !self.watermark_input_cols.is_empty() {
11974 len += 1;
11975 }
11976 if !self.watermark_output_cols.is_empty() {
11977 len += 1;
11978 }
11979 if !self.nondecreasing_exprs.is_empty() {
11980 len += 1;
11981 }
11982 if self.noop_update_hint {
11983 len += 1;
11984 }
11985 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
11986 if !self.select_list.is_empty() {
11987 struct_ser.serialize_field("selectList", &self.select_list)?;
11988 }
11989 if !self.watermark_input_cols.is_empty() {
11990 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
11991 }
11992 if !self.watermark_output_cols.is_empty() {
11993 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
11994 }
11995 if !self.nondecreasing_exprs.is_empty() {
11996 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
11997 }
11998 if self.noop_update_hint {
11999 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
12000 }
12001 struct_ser.end()
12002 }
12003}
12004impl<'de> serde::Deserialize<'de> for ProjectNode {
12005 #[allow(deprecated)]
12006 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12007 where
12008 D: serde::Deserializer<'de>,
12009 {
12010 const FIELDS: &[&str] = &[
12011 "select_list",
12012 "selectList",
12013 "watermark_input_cols",
12014 "watermarkInputCols",
12015 "watermark_output_cols",
12016 "watermarkOutputCols",
12017 "nondecreasing_exprs",
12018 "nondecreasingExprs",
12019 "noop_update_hint",
12020 "noopUpdateHint",
12021 ];
12022
12023 #[allow(clippy::enum_variant_names)]
12024 enum GeneratedField {
12025 SelectList,
12026 WatermarkInputCols,
12027 WatermarkOutputCols,
12028 NondecreasingExprs,
12029 NoopUpdateHint,
12030 }
12031 impl<'de> serde::Deserialize<'de> for GeneratedField {
12032 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12033 where
12034 D: serde::Deserializer<'de>,
12035 {
12036 struct GeneratedVisitor;
12037
12038 impl serde::de::Visitor<'_> for GeneratedVisitor {
12039 type Value = GeneratedField;
12040
12041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12042 write!(formatter, "expected one of: {:?}", &FIELDS)
12043 }
12044
12045 #[allow(unused_variables)]
12046 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12047 where
12048 E: serde::de::Error,
12049 {
12050 match value {
12051 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
12052 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
12053 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
12054 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
12055 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
12056 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12057 }
12058 }
12059 }
12060 deserializer.deserialize_identifier(GeneratedVisitor)
12061 }
12062 }
12063 struct GeneratedVisitor;
12064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12065 type Value = ProjectNode;
12066
12067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12068 formatter.write_str("struct stream_plan.ProjectNode")
12069 }
12070
12071 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
12072 where
12073 V: serde::de::MapAccess<'de>,
12074 {
12075 let mut select_list__ = None;
12076 let mut watermark_input_cols__ = None;
12077 let mut watermark_output_cols__ = None;
12078 let mut nondecreasing_exprs__ = None;
12079 let mut noop_update_hint__ = None;
12080 while let Some(k) = map_.next_key()? {
12081 match k {
12082 GeneratedField::SelectList => {
12083 if select_list__.is_some() {
12084 return Err(serde::de::Error::duplicate_field("selectList"));
12085 }
12086 select_list__ = Some(map_.next_value()?);
12087 }
12088 GeneratedField::WatermarkInputCols => {
12089 if watermark_input_cols__.is_some() {
12090 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
12091 }
12092 watermark_input_cols__ =
12093 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12094 .into_iter().map(|x| x.0).collect())
12095 ;
12096 }
12097 GeneratedField::WatermarkOutputCols => {
12098 if watermark_output_cols__.is_some() {
12099 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
12100 }
12101 watermark_output_cols__ =
12102 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12103 .into_iter().map(|x| x.0).collect())
12104 ;
12105 }
12106 GeneratedField::NondecreasingExprs => {
12107 if nondecreasing_exprs__.is_some() {
12108 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
12109 }
12110 nondecreasing_exprs__ =
12111 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12112 .into_iter().map(|x| x.0).collect())
12113 ;
12114 }
12115 GeneratedField::NoopUpdateHint => {
12116 if noop_update_hint__.is_some() {
12117 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
12118 }
12119 noop_update_hint__ = Some(map_.next_value()?);
12120 }
12121 }
12122 }
12123 Ok(ProjectNode {
12124 select_list: select_list__.unwrap_or_default(),
12125 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
12126 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
12127 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
12128 noop_update_hint: noop_update_hint__.unwrap_or_default(),
12129 })
12130 }
12131 }
12132 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
12133 }
12134}
12135impl serde::Serialize for ProjectSetNode {
12136 #[allow(deprecated)]
12137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12138 where
12139 S: serde::Serializer,
12140 {
12141 use serde::ser::SerializeStruct;
12142 let mut len = 0;
12143 if !self.select_list.is_empty() {
12144 len += 1;
12145 }
12146 if !self.watermark_input_cols.is_empty() {
12147 len += 1;
12148 }
12149 if !self.watermark_expr_indices.is_empty() {
12150 len += 1;
12151 }
12152 if !self.nondecreasing_exprs.is_empty() {
12153 len += 1;
12154 }
12155 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
12156 if !self.select_list.is_empty() {
12157 struct_ser.serialize_field("selectList", &self.select_list)?;
12158 }
12159 if !self.watermark_input_cols.is_empty() {
12160 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
12161 }
12162 if !self.watermark_expr_indices.is_empty() {
12163 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
12164 }
12165 if !self.nondecreasing_exprs.is_empty() {
12166 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
12167 }
12168 struct_ser.end()
12169 }
12170}
12171impl<'de> serde::Deserialize<'de> for ProjectSetNode {
12172 #[allow(deprecated)]
12173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12174 where
12175 D: serde::Deserializer<'de>,
12176 {
12177 const FIELDS: &[&str] = &[
12178 "select_list",
12179 "selectList",
12180 "watermark_input_cols",
12181 "watermarkInputCols",
12182 "watermark_expr_indices",
12183 "watermarkExprIndices",
12184 "nondecreasing_exprs",
12185 "nondecreasingExprs",
12186 ];
12187
12188 #[allow(clippy::enum_variant_names)]
12189 enum GeneratedField {
12190 SelectList,
12191 WatermarkInputCols,
12192 WatermarkExprIndices,
12193 NondecreasingExprs,
12194 }
12195 impl<'de> serde::Deserialize<'de> for GeneratedField {
12196 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12197 where
12198 D: serde::Deserializer<'de>,
12199 {
12200 struct GeneratedVisitor;
12201
12202 impl serde::de::Visitor<'_> for GeneratedVisitor {
12203 type Value = GeneratedField;
12204
12205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12206 write!(formatter, "expected one of: {:?}", &FIELDS)
12207 }
12208
12209 #[allow(unused_variables)]
12210 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12211 where
12212 E: serde::de::Error,
12213 {
12214 match value {
12215 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
12216 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
12217 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
12218 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
12219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12220 }
12221 }
12222 }
12223 deserializer.deserialize_identifier(GeneratedVisitor)
12224 }
12225 }
12226 struct GeneratedVisitor;
12227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12228 type Value = ProjectSetNode;
12229
12230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12231 formatter.write_str("struct stream_plan.ProjectSetNode")
12232 }
12233
12234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
12235 where
12236 V: serde::de::MapAccess<'de>,
12237 {
12238 let mut select_list__ = None;
12239 let mut watermark_input_cols__ = None;
12240 let mut watermark_expr_indices__ = None;
12241 let mut nondecreasing_exprs__ = None;
12242 while let Some(k) = map_.next_key()? {
12243 match k {
12244 GeneratedField::SelectList => {
12245 if select_list__.is_some() {
12246 return Err(serde::de::Error::duplicate_field("selectList"));
12247 }
12248 select_list__ = Some(map_.next_value()?);
12249 }
12250 GeneratedField::WatermarkInputCols => {
12251 if watermark_input_cols__.is_some() {
12252 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
12253 }
12254 watermark_input_cols__ =
12255 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12256 .into_iter().map(|x| x.0).collect())
12257 ;
12258 }
12259 GeneratedField::WatermarkExprIndices => {
12260 if watermark_expr_indices__.is_some() {
12261 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
12262 }
12263 watermark_expr_indices__ =
12264 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12265 .into_iter().map(|x| x.0).collect())
12266 ;
12267 }
12268 GeneratedField::NondecreasingExprs => {
12269 if nondecreasing_exprs__.is_some() {
12270 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
12271 }
12272 nondecreasing_exprs__ =
12273 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12274 .into_iter().map(|x| x.0).collect())
12275 ;
12276 }
12277 }
12278 }
12279 Ok(ProjectSetNode {
12280 select_list: select_list__.unwrap_or_default(),
12281 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
12282 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
12283 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
12284 })
12285 }
12286 }
12287 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
12288 }
12289}
12290impl serde::Serialize for RefreshStartMutation {
12291 #[allow(deprecated)]
12292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12293 where
12294 S: serde::Serializer,
12295 {
12296 use serde::ser::SerializeStruct;
12297 let mut len = 0;
12298 if self.table_id != 0 {
12299 len += 1;
12300 }
12301 if self.associated_source_id != 0 {
12302 len += 1;
12303 }
12304 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
12305 if self.table_id != 0 {
12306 struct_ser.serialize_field("tableId", &self.table_id)?;
12307 }
12308 if self.associated_source_id != 0 {
12309 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
12310 }
12311 struct_ser.end()
12312 }
12313}
12314impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
12315 #[allow(deprecated)]
12316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12317 where
12318 D: serde::Deserializer<'de>,
12319 {
12320 const FIELDS: &[&str] = &[
12321 "table_id",
12322 "tableId",
12323 "associated_source_id",
12324 "associatedSourceId",
12325 ];
12326
12327 #[allow(clippy::enum_variant_names)]
12328 enum GeneratedField {
12329 TableId,
12330 AssociatedSourceId,
12331 }
12332 impl<'de> serde::Deserialize<'de> for GeneratedField {
12333 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12334 where
12335 D: serde::Deserializer<'de>,
12336 {
12337 struct GeneratedVisitor;
12338
12339 impl serde::de::Visitor<'_> for GeneratedVisitor {
12340 type Value = GeneratedField;
12341
12342 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12343 write!(formatter, "expected one of: {:?}", &FIELDS)
12344 }
12345
12346 #[allow(unused_variables)]
12347 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12348 where
12349 E: serde::de::Error,
12350 {
12351 match value {
12352 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12353 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
12354 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12355 }
12356 }
12357 }
12358 deserializer.deserialize_identifier(GeneratedVisitor)
12359 }
12360 }
12361 struct GeneratedVisitor;
12362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12363 type Value = RefreshStartMutation;
12364
12365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12366 formatter.write_str("struct stream_plan.RefreshStartMutation")
12367 }
12368
12369 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
12370 where
12371 V: serde::de::MapAccess<'de>,
12372 {
12373 let mut table_id__ = None;
12374 let mut associated_source_id__ = None;
12375 while let Some(k) = map_.next_key()? {
12376 match k {
12377 GeneratedField::TableId => {
12378 if table_id__.is_some() {
12379 return Err(serde::de::Error::duplicate_field("tableId"));
12380 }
12381 table_id__ =
12382 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12383 ;
12384 }
12385 GeneratedField::AssociatedSourceId => {
12386 if associated_source_id__.is_some() {
12387 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
12388 }
12389 associated_source_id__ =
12390 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12391 ;
12392 }
12393 }
12394 }
12395 Ok(RefreshStartMutation {
12396 table_id: table_id__.unwrap_or_default(),
12397 associated_source_id: associated_source_id__.unwrap_or_default(),
12398 })
12399 }
12400 }
12401 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
12402 }
12403}
12404impl serde::Serialize for ResetSourceMutation {
12405 #[allow(deprecated)]
12406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12407 where
12408 S: serde::Serializer,
12409 {
12410 use serde::ser::SerializeStruct;
12411 let mut len = 0;
12412 if self.source_id != 0 {
12413 len += 1;
12414 }
12415 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
12416 if self.source_id != 0 {
12417 struct_ser.serialize_field("sourceId", &self.source_id)?;
12418 }
12419 struct_ser.end()
12420 }
12421}
12422impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
12423 #[allow(deprecated)]
12424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12425 where
12426 D: serde::Deserializer<'de>,
12427 {
12428 const FIELDS: &[&str] = &[
12429 "source_id",
12430 "sourceId",
12431 ];
12432
12433 #[allow(clippy::enum_variant_names)]
12434 enum GeneratedField {
12435 SourceId,
12436 }
12437 impl<'de> serde::Deserialize<'de> for GeneratedField {
12438 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12439 where
12440 D: serde::Deserializer<'de>,
12441 {
12442 struct GeneratedVisitor;
12443
12444 impl serde::de::Visitor<'_> for GeneratedVisitor {
12445 type Value = GeneratedField;
12446
12447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12448 write!(formatter, "expected one of: {:?}", &FIELDS)
12449 }
12450
12451 #[allow(unused_variables)]
12452 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12453 where
12454 E: serde::de::Error,
12455 {
12456 match value {
12457 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12459 }
12460 }
12461 }
12462 deserializer.deserialize_identifier(GeneratedVisitor)
12463 }
12464 }
12465 struct GeneratedVisitor;
12466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12467 type Value = ResetSourceMutation;
12468
12469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12470 formatter.write_str("struct stream_plan.ResetSourceMutation")
12471 }
12472
12473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
12474 where
12475 V: serde::de::MapAccess<'de>,
12476 {
12477 let mut source_id__ = None;
12478 while let Some(k) = map_.next_key()? {
12479 match k {
12480 GeneratedField::SourceId => {
12481 if source_id__.is_some() {
12482 return Err(serde::de::Error::duplicate_field("sourceId"));
12483 }
12484 source_id__ =
12485 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12486 ;
12487 }
12488 }
12489 }
12490 Ok(ResetSourceMutation {
12491 source_id: source_id__.unwrap_or_default(),
12492 })
12493 }
12494 }
12495 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
12496 }
12497}
12498impl serde::Serialize for ResumeMutation {
12499 #[allow(deprecated)]
12500 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12501 where
12502 S: serde::Serializer,
12503 {
12504 use serde::ser::SerializeStruct;
12505 let len = 0;
12506 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
12507 struct_ser.end()
12508 }
12509}
12510impl<'de> serde::Deserialize<'de> for ResumeMutation {
12511 #[allow(deprecated)]
12512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12513 where
12514 D: serde::Deserializer<'de>,
12515 {
12516 const FIELDS: &[&str] = &[
12517 ];
12518
12519 #[allow(clippy::enum_variant_names)]
12520 enum GeneratedField {
12521 }
12522 impl<'de> serde::Deserialize<'de> for GeneratedField {
12523 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12524 where
12525 D: serde::Deserializer<'de>,
12526 {
12527 struct GeneratedVisitor;
12528
12529 impl serde::de::Visitor<'_> for GeneratedVisitor {
12530 type Value = GeneratedField;
12531
12532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12533 write!(formatter, "expected one of: {:?}", &FIELDS)
12534 }
12535
12536 #[allow(unused_variables)]
12537 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12538 where
12539 E: serde::de::Error,
12540 {
12541 Err(serde::de::Error::unknown_field(value, FIELDS))
12542 }
12543 }
12544 deserializer.deserialize_identifier(GeneratedVisitor)
12545 }
12546 }
12547 struct GeneratedVisitor;
12548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12549 type Value = ResumeMutation;
12550
12551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12552 formatter.write_str("struct stream_plan.ResumeMutation")
12553 }
12554
12555 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
12556 where
12557 V: serde::de::MapAccess<'de>,
12558 {
12559 while map_.next_key::<GeneratedField>()?.is_some() {
12560 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12561 }
12562 Ok(ResumeMutation {
12563 })
12564 }
12565 }
12566 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
12567 }
12568}
12569impl serde::Serialize for RowIdGenNode {
12570 #[allow(deprecated)]
12571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12572 where
12573 S: serde::Serializer,
12574 {
12575 use serde::ser::SerializeStruct;
12576 let mut len = 0;
12577 if self.row_id_index != 0 {
12578 len += 1;
12579 }
12580 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
12581 if self.row_id_index != 0 {
12582 #[allow(clippy::needless_borrow)]
12583 #[allow(clippy::needless_borrows_for_generic_args)]
12584 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
12585 }
12586 struct_ser.end()
12587 }
12588}
12589impl<'de> serde::Deserialize<'de> for RowIdGenNode {
12590 #[allow(deprecated)]
12591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12592 where
12593 D: serde::Deserializer<'de>,
12594 {
12595 const FIELDS: &[&str] = &[
12596 "row_id_index",
12597 "rowIdIndex",
12598 ];
12599
12600 #[allow(clippy::enum_variant_names)]
12601 enum GeneratedField {
12602 RowIdIndex,
12603 }
12604 impl<'de> serde::Deserialize<'de> for GeneratedField {
12605 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12606 where
12607 D: serde::Deserializer<'de>,
12608 {
12609 struct GeneratedVisitor;
12610
12611 impl serde::de::Visitor<'_> for GeneratedVisitor {
12612 type Value = GeneratedField;
12613
12614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12615 write!(formatter, "expected one of: {:?}", &FIELDS)
12616 }
12617
12618 #[allow(unused_variables)]
12619 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12620 where
12621 E: serde::de::Error,
12622 {
12623 match value {
12624 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12625 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12626 }
12627 }
12628 }
12629 deserializer.deserialize_identifier(GeneratedVisitor)
12630 }
12631 }
12632 struct GeneratedVisitor;
12633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12634 type Value = RowIdGenNode;
12635
12636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12637 formatter.write_str("struct stream_plan.RowIdGenNode")
12638 }
12639
12640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
12641 where
12642 V: serde::de::MapAccess<'de>,
12643 {
12644 let mut row_id_index__ = None;
12645 while let Some(k) = map_.next_key()? {
12646 match k {
12647 GeneratedField::RowIdIndex => {
12648 if row_id_index__.is_some() {
12649 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12650 }
12651 row_id_index__ =
12652 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12653 ;
12654 }
12655 }
12656 }
12657 Ok(RowIdGenNode {
12658 row_id_index: row_id_index__.unwrap_or_default(),
12659 })
12660 }
12661 }
12662 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
12663 }
12664}
12665impl serde::Serialize for RowMergeNode {
12666 #[allow(deprecated)]
12667 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12668 where
12669 S: serde::Serializer,
12670 {
12671 use serde::ser::SerializeStruct;
12672 let mut len = 0;
12673 if self.lhs_mapping.is_some() {
12674 len += 1;
12675 }
12676 if self.rhs_mapping.is_some() {
12677 len += 1;
12678 }
12679 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
12680 if let Some(v) = self.lhs_mapping.as_ref() {
12681 struct_ser.serialize_field("lhsMapping", v)?;
12682 }
12683 if let Some(v) = self.rhs_mapping.as_ref() {
12684 struct_ser.serialize_field("rhsMapping", v)?;
12685 }
12686 struct_ser.end()
12687 }
12688}
12689impl<'de> serde::Deserialize<'de> for RowMergeNode {
12690 #[allow(deprecated)]
12691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12692 where
12693 D: serde::Deserializer<'de>,
12694 {
12695 const FIELDS: &[&str] = &[
12696 "lhs_mapping",
12697 "lhsMapping",
12698 "rhs_mapping",
12699 "rhsMapping",
12700 ];
12701
12702 #[allow(clippy::enum_variant_names)]
12703 enum GeneratedField {
12704 LhsMapping,
12705 RhsMapping,
12706 }
12707 impl<'de> serde::Deserialize<'de> for GeneratedField {
12708 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12709 where
12710 D: serde::Deserializer<'de>,
12711 {
12712 struct GeneratedVisitor;
12713
12714 impl serde::de::Visitor<'_> for GeneratedVisitor {
12715 type Value = GeneratedField;
12716
12717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12718 write!(formatter, "expected one of: {:?}", &FIELDS)
12719 }
12720
12721 #[allow(unused_variables)]
12722 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12723 where
12724 E: serde::de::Error,
12725 {
12726 match value {
12727 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
12728 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
12729 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12730 }
12731 }
12732 }
12733 deserializer.deserialize_identifier(GeneratedVisitor)
12734 }
12735 }
12736 struct GeneratedVisitor;
12737 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12738 type Value = RowMergeNode;
12739
12740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12741 formatter.write_str("struct stream_plan.RowMergeNode")
12742 }
12743
12744 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
12745 where
12746 V: serde::de::MapAccess<'de>,
12747 {
12748 let mut lhs_mapping__ = None;
12749 let mut rhs_mapping__ = None;
12750 while let Some(k) = map_.next_key()? {
12751 match k {
12752 GeneratedField::LhsMapping => {
12753 if lhs_mapping__.is_some() {
12754 return Err(serde::de::Error::duplicate_field("lhsMapping"));
12755 }
12756 lhs_mapping__ = map_.next_value()?;
12757 }
12758 GeneratedField::RhsMapping => {
12759 if rhs_mapping__.is_some() {
12760 return Err(serde::de::Error::duplicate_field("rhsMapping"));
12761 }
12762 rhs_mapping__ = map_.next_value()?;
12763 }
12764 }
12765 }
12766 Ok(RowMergeNode {
12767 lhs_mapping: lhs_mapping__,
12768 rhs_mapping: rhs_mapping__,
12769 })
12770 }
12771 }
12772 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
12773 }
12774}
12775impl serde::Serialize for SimpleAggNode {
12776 #[allow(deprecated)]
12777 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12778 where
12779 S: serde::Serializer,
12780 {
12781 use serde::ser::SerializeStruct;
12782 let mut len = 0;
12783 if !self.agg_calls.is_empty() {
12784 len += 1;
12785 }
12786 if !self.agg_call_states.is_empty() {
12787 len += 1;
12788 }
12789 if self.intermediate_state_table.is_some() {
12790 len += 1;
12791 }
12792 if self.is_append_only {
12793 len += 1;
12794 }
12795 if !self.distinct_dedup_tables.is_empty() {
12796 len += 1;
12797 }
12798 if self.row_count_index != 0 {
12799 len += 1;
12800 }
12801 if self.version != 0 {
12802 len += 1;
12803 }
12804 if self.must_output_per_barrier {
12805 len += 1;
12806 }
12807 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
12808 if !self.agg_calls.is_empty() {
12809 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
12810 }
12811 if !self.agg_call_states.is_empty() {
12812 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
12813 }
12814 if let Some(v) = self.intermediate_state_table.as_ref() {
12815 struct_ser.serialize_field("intermediateStateTable", v)?;
12816 }
12817 if self.is_append_only {
12818 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
12819 }
12820 if !self.distinct_dedup_tables.is_empty() {
12821 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
12822 }
12823 if self.row_count_index != 0 {
12824 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
12825 }
12826 if self.version != 0 {
12827 let v = AggNodeVersion::try_from(self.version)
12828 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
12829 struct_ser.serialize_field("version", &v)?;
12830 }
12831 if self.must_output_per_barrier {
12832 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
12833 }
12834 struct_ser.end()
12835 }
12836}
12837impl<'de> serde::Deserialize<'de> for SimpleAggNode {
12838 #[allow(deprecated)]
12839 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12840 where
12841 D: serde::Deserializer<'de>,
12842 {
12843 const FIELDS: &[&str] = &[
12844 "agg_calls",
12845 "aggCalls",
12846 "agg_call_states",
12847 "aggCallStates",
12848 "intermediate_state_table",
12849 "intermediateStateTable",
12850 "is_append_only",
12851 "isAppendOnly",
12852 "distinct_dedup_tables",
12853 "distinctDedupTables",
12854 "row_count_index",
12855 "rowCountIndex",
12856 "version",
12857 "must_output_per_barrier",
12858 "mustOutputPerBarrier",
12859 ];
12860
12861 #[allow(clippy::enum_variant_names)]
12862 enum GeneratedField {
12863 AggCalls,
12864 AggCallStates,
12865 IntermediateStateTable,
12866 IsAppendOnly,
12867 DistinctDedupTables,
12868 RowCountIndex,
12869 Version,
12870 MustOutputPerBarrier,
12871 }
12872 impl<'de> serde::Deserialize<'de> for GeneratedField {
12873 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12874 where
12875 D: serde::Deserializer<'de>,
12876 {
12877 struct GeneratedVisitor;
12878
12879 impl serde::de::Visitor<'_> for GeneratedVisitor {
12880 type Value = GeneratedField;
12881
12882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12883 write!(formatter, "expected one of: {:?}", &FIELDS)
12884 }
12885
12886 #[allow(unused_variables)]
12887 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12888 where
12889 E: serde::de::Error,
12890 {
12891 match value {
12892 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
12893 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
12894 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
12895 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
12896 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
12897 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
12898 "version" => Ok(GeneratedField::Version),
12899 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
12900 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12901 }
12902 }
12903 }
12904 deserializer.deserialize_identifier(GeneratedVisitor)
12905 }
12906 }
12907 struct GeneratedVisitor;
12908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12909 type Value = SimpleAggNode;
12910
12911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12912 formatter.write_str("struct stream_plan.SimpleAggNode")
12913 }
12914
12915 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
12916 where
12917 V: serde::de::MapAccess<'de>,
12918 {
12919 let mut agg_calls__ = None;
12920 let mut agg_call_states__ = None;
12921 let mut intermediate_state_table__ = None;
12922 let mut is_append_only__ = None;
12923 let mut distinct_dedup_tables__ = None;
12924 let mut row_count_index__ = None;
12925 let mut version__ = None;
12926 let mut must_output_per_barrier__ = None;
12927 while let Some(k) = map_.next_key()? {
12928 match k {
12929 GeneratedField::AggCalls => {
12930 if agg_calls__.is_some() {
12931 return Err(serde::de::Error::duplicate_field("aggCalls"));
12932 }
12933 agg_calls__ = Some(map_.next_value()?);
12934 }
12935 GeneratedField::AggCallStates => {
12936 if agg_call_states__.is_some() {
12937 return Err(serde::de::Error::duplicate_field("aggCallStates"));
12938 }
12939 agg_call_states__ = Some(map_.next_value()?);
12940 }
12941 GeneratedField::IntermediateStateTable => {
12942 if intermediate_state_table__.is_some() {
12943 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
12944 }
12945 intermediate_state_table__ = map_.next_value()?;
12946 }
12947 GeneratedField::IsAppendOnly => {
12948 if is_append_only__.is_some() {
12949 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
12950 }
12951 is_append_only__ = Some(map_.next_value()?);
12952 }
12953 GeneratedField::DistinctDedupTables => {
12954 if distinct_dedup_tables__.is_some() {
12955 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
12956 }
12957 distinct_dedup_tables__ = Some(
12958 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12959 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12960 );
12961 }
12962 GeneratedField::RowCountIndex => {
12963 if row_count_index__.is_some() {
12964 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
12965 }
12966 row_count_index__ =
12967 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12968 ;
12969 }
12970 GeneratedField::Version => {
12971 if version__.is_some() {
12972 return Err(serde::de::Error::duplicate_field("version"));
12973 }
12974 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
12975 }
12976 GeneratedField::MustOutputPerBarrier => {
12977 if must_output_per_barrier__.is_some() {
12978 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
12979 }
12980 must_output_per_barrier__ = Some(map_.next_value()?);
12981 }
12982 }
12983 }
12984 Ok(SimpleAggNode {
12985 agg_calls: agg_calls__.unwrap_or_default(),
12986 agg_call_states: agg_call_states__.unwrap_or_default(),
12987 intermediate_state_table: intermediate_state_table__,
12988 is_append_only: is_append_only__.unwrap_or_default(),
12989 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
12990 row_count_index: row_count_index__.unwrap_or_default(),
12991 version: version__.unwrap_or_default(),
12992 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
12993 })
12994 }
12995 }
12996 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
12997 }
12998}
12999impl serde::Serialize for SinkAddColumnsOp {
13000 #[allow(deprecated)]
13001 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13002 where
13003 S: serde::Serializer,
13004 {
13005 use serde::ser::SerializeStruct;
13006 let mut len = 0;
13007 if !self.fields.is_empty() {
13008 len += 1;
13009 }
13010 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
13011 if !self.fields.is_empty() {
13012 struct_ser.serialize_field("fields", &self.fields)?;
13013 }
13014 struct_ser.end()
13015 }
13016}
13017impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
13018 #[allow(deprecated)]
13019 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13020 where
13021 D: serde::Deserializer<'de>,
13022 {
13023 const FIELDS: &[&str] = &[
13024 "fields",
13025 ];
13026
13027 #[allow(clippy::enum_variant_names)]
13028 enum GeneratedField {
13029 Fields,
13030 }
13031 impl<'de> serde::Deserialize<'de> for GeneratedField {
13032 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13033 where
13034 D: serde::Deserializer<'de>,
13035 {
13036 struct GeneratedVisitor;
13037
13038 impl serde::de::Visitor<'_> for GeneratedVisitor {
13039 type Value = GeneratedField;
13040
13041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13042 write!(formatter, "expected one of: {:?}", &FIELDS)
13043 }
13044
13045 #[allow(unused_variables)]
13046 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13047 where
13048 E: serde::de::Error,
13049 {
13050 match value {
13051 "fields" => Ok(GeneratedField::Fields),
13052 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13053 }
13054 }
13055 }
13056 deserializer.deserialize_identifier(GeneratedVisitor)
13057 }
13058 }
13059 struct GeneratedVisitor;
13060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13061 type Value = SinkAddColumnsOp;
13062
13063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13064 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
13065 }
13066
13067 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
13068 where
13069 V: serde::de::MapAccess<'de>,
13070 {
13071 let mut fields__ = None;
13072 while let Some(k) = map_.next_key()? {
13073 match k {
13074 GeneratedField::Fields => {
13075 if fields__.is_some() {
13076 return Err(serde::de::Error::duplicate_field("fields"));
13077 }
13078 fields__ = Some(map_.next_value()?);
13079 }
13080 }
13081 }
13082 Ok(SinkAddColumnsOp {
13083 fields: fields__.unwrap_or_default(),
13084 })
13085 }
13086 }
13087 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
13088 }
13089}
13090impl serde::Serialize for SinkDesc {
13091 #[allow(deprecated)]
13092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13093 where
13094 S: serde::Serializer,
13095 {
13096 use serde::ser::SerializeStruct;
13097 let mut len = 0;
13098 if self.id != 0 {
13099 len += 1;
13100 }
13101 if !self.name.is_empty() {
13102 len += 1;
13103 }
13104 if !self.definition.is_empty() {
13105 len += 1;
13106 }
13107 if !self.plan_pk.is_empty() {
13108 len += 1;
13109 }
13110 if !self.downstream_pk.is_empty() {
13111 len += 1;
13112 }
13113 if !self.distribution_key.is_empty() {
13114 len += 1;
13115 }
13116 if !self.properties.is_empty() {
13117 len += 1;
13118 }
13119 if self.sink_type != 0 {
13120 len += 1;
13121 }
13122 if !self.column_catalogs.is_empty() {
13123 len += 1;
13124 }
13125 if !self.db_name.is_empty() {
13126 len += 1;
13127 }
13128 if !self.sink_from_name.is_empty() {
13129 len += 1;
13130 }
13131 if self.format_desc.is_some() {
13132 len += 1;
13133 }
13134 if self.target_table.is_some() {
13135 len += 1;
13136 }
13137 if self.extra_partition_col_idx.is_some() {
13138 len += 1;
13139 }
13140 if !self.secret_refs.is_empty() {
13141 len += 1;
13142 }
13143 if self.raw_ignore_delete {
13144 len += 1;
13145 }
13146 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
13147 if self.id != 0 {
13148 struct_ser.serialize_field("id", &self.id)?;
13149 }
13150 if !self.name.is_empty() {
13151 struct_ser.serialize_field("name", &self.name)?;
13152 }
13153 if !self.definition.is_empty() {
13154 struct_ser.serialize_field("definition", &self.definition)?;
13155 }
13156 if !self.plan_pk.is_empty() {
13157 struct_ser.serialize_field("planPk", &self.plan_pk)?;
13158 }
13159 if !self.downstream_pk.is_empty() {
13160 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
13161 }
13162 if !self.distribution_key.is_empty() {
13163 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
13164 }
13165 if !self.properties.is_empty() {
13166 struct_ser.serialize_field("properties", &self.properties)?;
13167 }
13168 if self.sink_type != 0 {
13169 let v = super::catalog::SinkType::try_from(self.sink_type)
13170 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
13171 struct_ser.serialize_field("sinkType", &v)?;
13172 }
13173 if !self.column_catalogs.is_empty() {
13174 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
13175 }
13176 if !self.db_name.is_empty() {
13177 struct_ser.serialize_field("dbName", &self.db_name)?;
13178 }
13179 if !self.sink_from_name.is_empty() {
13180 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
13181 }
13182 if let Some(v) = self.format_desc.as_ref() {
13183 struct_ser.serialize_field("formatDesc", v)?;
13184 }
13185 if let Some(v) = self.target_table.as_ref() {
13186 struct_ser.serialize_field("targetTable", v)?;
13187 }
13188 if let Some(v) = self.extra_partition_col_idx.as_ref() {
13189 #[allow(clippy::needless_borrow)]
13190 #[allow(clippy::needless_borrows_for_generic_args)]
13191 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
13192 }
13193 if !self.secret_refs.is_empty() {
13194 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13195 }
13196 if self.raw_ignore_delete {
13197 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
13198 }
13199 struct_ser.end()
13200 }
13201}
13202impl<'de> serde::Deserialize<'de> for SinkDesc {
13203 #[allow(deprecated)]
13204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13205 where
13206 D: serde::Deserializer<'de>,
13207 {
13208 const FIELDS: &[&str] = &[
13209 "id",
13210 "name",
13211 "definition",
13212 "plan_pk",
13213 "planPk",
13214 "downstream_pk",
13215 "downstreamPk",
13216 "distribution_key",
13217 "distributionKey",
13218 "properties",
13219 "sink_type",
13220 "sinkType",
13221 "column_catalogs",
13222 "columnCatalogs",
13223 "db_name",
13224 "dbName",
13225 "sink_from_name",
13226 "sinkFromName",
13227 "format_desc",
13228 "formatDesc",
13229 "target_table",
13230 "targetTable",
13231 "extra_partition_col_idx",
13232 "extraPartitionColIdx",
13233 "secret_refs",
13234 "secretRefs",
13235 "raw_ignore_delete",
13236 "rawIgnoreDelete",
13237 ];
13238
13239 #[allow(clippy::enum_variant_names)]
13240 enum GeneratedField {
13241 Id,
13242 Name,
13243 Definition,
13244 PlanPk,
13245 DownstreamPk,
13246 DistributionKey,
13247 Properties,
13248 SinkType,
13249 ColumnCatalogs,
13250 DbName,
13251 SinkFromName,
13252 FormatDesc,
13253 TargetTable,
13254 ExtraPartitionColIdx,
13255 SecretRefs,
13256 RawIgnoreDelete,
13257 }
13258 impl<'de> serde::Deserialize<'de> for GeneratedField {
13259 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13260 where
13261 D: serde::Deserializer<'de>,
13262 {
13263 struct GeneratedVisitor;
13264
13265 impl serde::de::Visitor<'_> for GeneratedVisitor {
13266 type Value = GeneratedField;
13267
13268 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13269 write!(formatter, "expected one of: {:?}", &FIELDS)
13270 }
13271
13272 #[allow(unused_variables)]
13273 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13274 where
13275 E: serde::de::Error,
13276 {
13277 match value {
13278 "id" => Ok(GeneratedField::Id),
13279 "name" => Ok(GeneratedField::Name),
13280 "definition" => Ok(GeneratedField::Definition),
13281 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
13282 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
13283 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
13284 "properties" => Ok(GeneratedField::Properties),
13285 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
13286 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
13287 "dbName" | "db_name" => Ok(GeneratedField::DbName),
13288 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
13289 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
13290 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
13291 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
13292 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13293 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
13294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13295 }
13296 }
13297 }
13298 deserializer.deserialize_identifier(GeneratedVisitor)
13299 }
13300 }
13301 struct GeneratedVisitor;
13302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13303 type Value = SinkDesc;
13304
13305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13306 formatter.write_str("struct stream_plan.SinkDesc")
13307 }
13308
13309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
13310 where
13311 V: serde::de::MapAccess<'de>,
13312 {
13313 let mut id__ = None;
13314 let mut name__ = None;
13315 let mut definition__ = None;
13316 let mut plan_pk__ = None;
13317 let mut downstream_pk__ = None;
13318 let mut distribution_key__ = None;
13319 let mut properties__ = None;
13320 let mut sink_type__ = None;
13321 let mut column_catalogs__ = None;
13322 let mut db_name__ = None;
13323 let mut sink_from_name__ = None;
13324 let mut format_desc__ = None;
13325 let mut target_table__ = None;
13326 let mut extra_partition_col_idx__ = None;
13327 let mut secret_refs__ = None;
13328 let mut raw_ignore_delete__ = None;
13329 while let Some(k) = map_.next_key()? {
13330 match k {
13331 GeneratedField::Id => {
13332 if id__.is_some() {
13333 return Err(serde::de::Error::duplicate_field("id"));
13334 }
13335 id__ =
13336 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13337 ;
13338 }
13339 GeneratedField::Name => {
13340 if name__.is_some() {
13341 return Err(serde::de::Error::duplicate_field("name"));
13342 }
13343 name__ = Some(map_.next_value()?);
13344 }
13345 GeneratedField::Definition => {
13346 if definition__.is_some() {
13347 return Err(serde::de::Error::duplicate_field("definition"));
13348 }
13349 definition__ = Some(map_.next_value()?);
13350 }
13351 GeneratedField::PlanPk => {
13352 if plan_pk__.is_some() {
13353 return Err(serde::de::Error::duplicate_field("planPk"));
13354 }
13355 plan_pk__ = Some(map_.next_value()?);
13356 }
13357 GeneratedField::DownstreamPk => {
13358 if downstream_pk__.is_some() {
13359 return Err(serde::de::Error::duplicate_field("downstreamPk"));
13360 }
13361 downstream_pk__ =
13362 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13363 .into_iter().map(|x| x.0).collect())
13364 ;
13365 }
13366 GeneratedField::DistributionKey => {
13367 if distribution_key__.is_some() {
13368 return Err(serde::de::Error::duplicate_field("distributionKey"));
13369 }
13370 distribution_key__ =
13371 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13372 .into_iter().map(|x| x.0).collect())
13373 ;
13374 }
13375 GeneratedField::Properties => {
13376 if properties__.is_some() {
13377 return Err(serde::de::Error::duplicate_field("properties"));
13378 }
13379 properties__ = Some(
13380 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13381 );
13382 }
13383 GeneratedField::SinkType => {
13384 if sink_type__.is_some() {
13385 return Err(serde::de::Error::duplicate_field("sinkType"));
13386 }
13387 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
13388 }
13389 GeneratedField::ColumnCatalogs => {
13390 if column_catalogs__.is_some() {
13391 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
13392 }
13393 column_catalogs__ = Some(map_.next_value()?);
13394 }
13395 GeneratedField::DbName => {
13396 if db_name__.is_some() {
13397 return Err(serde::de::Error::duplicate_field("dbName"));
13398 }
13399 db_name__ = Some(map_.next_value()?);
13400 }
13401 GeneratedField::SinkFromName => {
13402 if sink_from_name__.is_some() {
13403 return Err(serde::de::Error::duplicate_field("sinkFromName"));
13404 }
13405 sink_from_name__ = Some(map_.next_value()?);
13406 }
13407 GeneratedField::FormatDesc => {
13408 if format_desc__.is_some() {
13409 return Err(serde::de::Error::duplicate_field("formatDesc"));
13410 }
13411 format_desc__ = map_.next_value()?;
13412 }
13413 GeneratedField::TargetTable => {
13414 if target_table__.is_some() {
13415 return Err(serde::de::Error::duplicate_field("targetTable"));
13416 }
13417 target_table__ =
13418 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13419 ;
13420 }
13421 GeneratedField::ExtraPartitionColIdx => {
13422 if extra_partition_col_idx__.is_some() {
13423 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
13424 }
13425 extra_partition_col_idx__ =
13426 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13427 ;
13428 }
13429 GeneratedField::SecretRefs => {
13430 if secret_refs__.is_some() {
13431 return Err(serde::de::Error::duplicate_field("secretRefs"));
13432 }
13433 secret_refs__ = Some(
13434 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13435 );
13436 }
13437 GeneratedField::RawIgnoreDelete => {
13438 if raw_ignore_delete__.is_some() {
13439 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
13440 }
13441 raw_ignore_delete__ = Some(map_.next_value()?);
13442 }
13443 }
13444 }
13445 Ok(SinkDesc {
13446 id: id__.unwrap_or_default(),
13447 name: name__.unwrap_or_default(),
13448 definition: definition__.unwrap_or_default(),
13449 plan_pk: plan_pk__.unwrap_or_default(),
13450 downstream_pk: downstream_pk__.unwrap_or_default(),
13451 distribution_key: distribution_key__.unwrap_or_default(),
13452 properties: properties__.unwrap_or_default(),
13453 sink_type: sink_type__.unwrap_or_default(),
13454 column_catalogs: column_catalogs__.unwrap_or_default(),
13455 db_name: db_name__.unwrap_or_default(),
13456 sink_from_name: sink_from_name__.unwrap_or_default(),
13457 format_desc: format_desc__,
13458 target_table: target_table__,
13459 extra_partition_col_idx: extra_partition_col_idx__,
13460 secret_refs: secret_refs__.unwrap_or_default(),
13461 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
13462 })
13463 }
13464 }
13465 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
13466 }
13467}
13468impl serde::Serialize for SinkDropColumnsOp {
13469 #[allow(deprecated)]
13470 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13471 where
13472 S: serde::Serializer,
13473 {
13474 use serde::ser::SerializeStruct;
13475 let mut len = 0;
13476 if !self.column_names.is_empty() {
13477 len += 1;
13478 }
13479 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
13480 if !self.column_names.is_empty() {
13481 struct_ser.serialize_field("columnNames", &self.column_names)?;
13482 }
13483 struct_ser.end()
13484 }
13485}
13486impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
13487 #[allow(deprecated)]
13488 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13489 where
13490 D: serde::Deserializer<'de>,
13491 {
13492 const FIELDS: &[&str] = &[
13493 "column_names",
13494 "columnNames",
13495 ];
13496
13497 #[allow(clippy::enum_variant_names)]
13498 enum GeneratedField {
13499 ColumnNames,
13500 }
13501 impl<'de> serde::Deserialize<'de> for GeneratedField {
13502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13503 where
13504 D: serde::Deserializer<'de>,
13505 {
13506 struct GeneratedVisitor;
13507
13508 impl serde::de::Visitor<'_> for GeneratedVisitor {
13509 type Value = GeneratedField;
13510
13511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13512 write!(formatter, "expected one of: {:?}", &FIELDS)
13513 }
13514
13515 #[allow(unused_variables)]
13516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13517 where
13518 E: serde::de::Error,
13519 {
13520 match value {
13521 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
13522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13523 }
13524 }
13525 }
13526 deserializer.deserialize_identifier(GeneratedVisitor)
13527 }
13528 }
13529 struct GeneratedVisitor;
13530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13531 type Value = SinkDropColumnsOp;
13532
13533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13534 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
13535 }
13536
13537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
13538 where
13539 V: serde::de::MapAccess<'de>,
13540 {
13541 let mut column_names__ = None;
13542 while let Some(k) = map_.next_key()? {
13543 match k {
13544 GeneratedField::ColumnNames => {
13545 if column_names__.is_some() {
13546 return Err(serde::de::Error::duplicate_field("columnNames"));
13547 }
13548 column_names__ = Some(map_.next_value()?);
13549 }
13550 }
13551 }
13552 Ok(SinkDropColumnsOp {
13553 column_names: column_names__.unwrap_or_default(),
13554 })
13555 }
13556 }
13557 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
13558 }
13559}
13560impl serde::Serialize for SinkLogStoreType {
13561 #[allow(deprecated)]
13562 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13563 where
13564 S: serde::Serializer,
13565 {
13566 let variant = match self {
13567 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
13568 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
13569 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
13570 };
13571 serializer.serialize_str(variant)
13572 }
13573}
13574impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
13575 #[allow(deprecated)]
13576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13577 where
13578 D: serde::Deserializer<'de>,
13579 {
13580 const FIELDS: &[&str] = &[
13581 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
13582 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
13583 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
13584 ];
13585
13586 struct GeneratedVisitor;
13587
13588 impl serde::de::Visitor<'_> for GeneratedVisitor {
13589 type Value = SinkLogStoreType;
13590
13591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13592 write!(formatter, "expected one of: {:?}", &FIELDS)
13593 }
13594
13595 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13596 where
13597 E: serde::de::Error,
13598 {
13599 i32::try_from(v)
13600 .ok()
13601 .and_then(|x| x.try_into().ok())
13602 .ok_or_else(|| {
13603 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13604 })
13605 }
13606
13607 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13608 where
13609 E: serde::de::Error,
13610 {
13611 i32::try_from(v)
13612 .ok()
13613 .and_then(|x| x.try_into().ok())
13614 .ok_or_else(|| {
13615 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13616 })
13617 }
13618
13619 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13620 where
13621 E: serde::de::Error,
13622 {
13623 match value {
13624 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
13625 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
13626 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
13627 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13628 }
13629 }
13630 }
13631 deserializer.deserialize_any(GeneratedVisitor)
13632 }
13633}
13634impl serde::Serialize for SinkNode {
13635 #[allow(deprecated)]
13636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13637 where
13638 S: serde::Serializer,
13639 {
13640 use serde::ser::SerializeStruct;
13641 let mut len = 0;
13642 if self.sink_desc.is_some() {
13643 len += 1;
13644 }
13645 if self.table.is_some() {
13646 len += 1;
13647 }
13648 if self.log_store_type != 0 {
13649 len += 1;
13650 }
13651 if self.rate_limit.is_some() {
13652 len += 1;
13653 }
13654 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
13655 if let Some(v) = self.sink_desc.as_ref() {
13656 struct_ser.serialize_field("sinkDesc", v)?;
13657 }
13658 if let Some(v) = self.table.as_ref() {
13659 struct_ser.serialize_field("table", v)?;
13660 }
13661 if self.log_store_type != 0 {
13662 let v = SinkLogStoreType::try_from(self.log_store_type)
13663 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
13664 struct_ser.serialize_field("logStoreType", &v)?;
13665 }
13666 if let Some(v) = self.rate_limit.as_ref() {
13667 struct_ser.serialize_field("rateLimit", v)?;
13668 }
13669 struct_ser.end()
13670 }
13671}
13672impl<'de> serde::Deserialize<'de> for SinkNode {
13673 #[allow(deprecated)]
13674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13675 where
13676 D: serde::Deserializer<'de>,
13677 {
13678 const FIELDS: &[&str] = &[
13679 "sink_desc",
13680 "sinkDesc",
13681 "table",
13682 "log_store_type",
13683 "logStoreType",
13684 "rate_limit",
13685 "rateLimit",
13686 ];
13687
13688 #[allow(clippy::enum_variant_names)]
13689 enum GeneratedField {
13690 SinkDesc,
13691 Table,
13692 LogStoreType,
13693 RateLimit,
13694 }
13695 impl<'de> serde::Deserialize<'de> for GeneratedField {
13696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13697 where
13698 D: serde::Deserializer<'de>,
13699 {
13700 struct GeneratedVisitor;
13701
13702 impl serde::de::Visitor<'_> for GeneratedVisitor {
13703 type Value = GeneratedField;
13704
13705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13706 write!(formatter, "expected one of: {:?}", &FIELDS)
13707 }
13708
13709 #[allow(unused_variables)]
13710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13711 where
13712 E: serde::de::Error,
13713 {
13714 match value {
13715 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
13716 "table" => Ok(GeneratedField::Table),
13717 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
13718 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13719 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13720 }
13721 }
13722 }
13723 deserializer.deserialize_identifier(GeneratedVisitor)
13724 }
13725 }
13726 struct GeneratedVisitor;
13727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13728 type Value = SinkNode;
13729
13730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13731 formatter.write_str("struct stream_plan.SinkNode")
13732 }
13733
13734 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
13735 where
13736 V: serde::de::MapAccess<'de>,
13737 {
13738 let mut sink_desc__ = None;
13739 let mut table__ = None;
13740 let mut log_store_type__ = None;
13741 let mut rate_limit__ = None;
13742 while let Some(k) = map_.next_key()? {
13743 match k {
13744 GeneratedField::SinkDesc => {
13745 if sink_desc__.is_some() {
13746 return Err(serde::de::Error::duplicate_field("sinkDesc"));
13747 }
13748 sink_desc__ = map_.next_value()?;
13749 }
13750 GeneratedField::Table => {
13751 if table__.is_some() {
13752 return Err(serde::de::Error::duplicate_field("table"));
13753 }
13754 table__ = map_.next_value()?;
13755 }
13756 GeneratedField::LogStoreType => {
13757 if log_store_type__.is_some() {
13758 return Err(serde::de::Error::duplicate_field("logStoreType"));
13759 }
13760 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
13761 }
13762 GeneratedField::RateLimit => {
13763 if rate_limit__.is_some() {
13764 return Err(serde::de::Error::duplicate_field("rateLimit"));
13765 }
13766 rate_limit__ =
13767 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13768 ;
13769 }
13770 }
13771 }
13772 Ok(SinkNode {
13773 sink_desc: sink_desc__,
13774 table: table__,
13775 log_store_type: log_store_type__.unwrap_or_default(),
13776 rate_limit: rate_limit__,
13777 })
13778 }
13779 }
13780 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
13781 }
13782}
13783impl serde::Serialize for SinkSchemaChange {
13784 #[allow(deprecated)]
13785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13786 where
13787 S: serde::Serializer,
13788 {
13789 use serde::ser::SerializeStruct;
13790 let mut len = 0;
13791 if !self.original_schema.is_empty() {
13792 len += 1;
13793 }
13794 if self.op.is_some() {
13795 len += 1;
13796 }
13797 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
13798 if !self.original_schema.is_empty() {
13799 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
13800 }
13801 if let Some(v) = self.op.as_ref() {
13802 match v {
13803 sink_schema_change::Op::AddColumns(v) => {
13804 struct_ser.serialize_field("addColumns", v)?;
13805 }
13806 sink_schema_change::Op::DropColumns(v) => {
13807 struct_ser.serialize_field("dropColumns", v)?;
13808 }
13809 }
13810 }
13811 struct_ser.end()
13812 }
13813}
13814impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
13815 #[allow(deprecated)]
13816 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13817 where
13818 D: serde::Deserializer<'de>,
13819 {
13820 const FIELDS: &[&str] = &[
13821 "original_schema",
13822 "originalSchema",
13823 "add_columns",
13824 "addColumns",
13825 "drop_columns",
13826 "dropColumns",
13827 ];
13828
13829 #[allow(clippy::enum_variant_names)]
13830 enum GeneratedField {
13831 OriginalSchema,
13832 AddColumns,
13833 DropColumns,
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 serde::de::Visitor<'_> 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 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
13856 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
13857 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
13858 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13859 }
13860 }
13861 }
13862 deserializer.deserialize_identifier(GeneratedVisitor)
13863 }
13864 }
13865 struct GeneratedVisitor;
13866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13867 type Value = SinkSchemaChange;
13868
13869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13870 formatter.write_str("struct stream_plan.SinkSchemaChange")
13871 }
13872
13873 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
13874 where
13875 V: serde::de::MapAccess<'de>,
13876 {
13877 let mut original_schema__ = None;
13878 let mut op__ = None;
13879 while let Some(k) = map_.next_key()? {
13880 match k {
13881 GeneratedField::OriginalSchema => {
13882 if original_schema__.is_some() {
13883 return Err(serde::de::Error::duplicate_field("originalSchema"));
13884 }
13885 original_schema__ = Some(map_.next_value()?);
13886 }
13887 GeneratedField::AddColumns => {
13888 if op__.is_some() {
13889 return Err(serde::de::Error::duplicate_field("addColumns"));
13890 }
13891 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
13892;
13893 }
13894 GeneratedField::DropColumns => {
13895 if op__.is_some() {
13896 return Err(serde::de::Error::duplicate_field("dropColumns"));
13897 }
13898 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
13899;
13900 }
13901 }
13902 }
13903 Ok(SinkSchemaChange {
13904 original_schema: original_schema__.unwrap_or_default(),
13905 op: op__,
13906 })
13907 }
13908 }
13909 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
13910 }
13911}
13912impl serde::Serialize for SortNode {
13913 #[allow(deprecated)]
13914 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13915 where
13916 S: serde::Serializer,
13917 {
13918 use serde::ser::SerializeStruct;
13919 let mut len = 0;
13920 if self.state_table.is_some() {
13921 len += 1;
13922 }
13923 if self.sort_column_index != 0 {
13924 len += 1;
13925 }
13926 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
13927 if let Some(v) = self.state_table.as_ref() {
13928 struct_ser.serialize_field("stateTable", v)?;
13929 }
13930 if self.sort_column_index != 0 {
13931 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
13932 }
13933 struct_ser.end()
13934 }
13935}
13936impl<'de> serde::Deserialize<'de> for SortNode {
13937 #[allow(deprecated)]
13938 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13939 where
13940 D: serde::Deserializer<'de>,
13941 {
13942 const FIELDS: &[&str] = &[
13943 "state_table",
13944 "stateTable",
13945 "sort_column_index",
13946 "sortColumnIndex",
13947 ];
13948
13949 #[allow(clippy::enum_variant_names)]
13950 enum GeneratedField {
13951 StateTable,
13952 SortColumnIndex,
13953 }
13954 impl<'de> serde::Deserialize<'de> for GeneratedField {
13955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13956 where
13957 D: serde::Deserializer<'de>,
13958 {
13959 struct GeneratedVisitor;
13960
13961 impl serde::de::Visitor<'_> for GeneratedVisitor {
13962 type Value = GeneratedField;
13963
13964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13965 write!(formatter, "expected one of: {:?}", &FIELDS)
13966 }
13967
13968 #[allow(unused_variables)]
13969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13970 where
13971 E: serde::de::Error,
13972 {
13973 match value {
13974 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13975 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
13976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13977 }
13978 }
13979 }
13980 deserializer.deserialize_identifier(GeneratedVisitor)
13981 }
13982 }
13983 struct GeneratedVisitor;
13984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13985 type Value = SortNode;
13986
13987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13988 formatter.write_str("struct stream_plan.SortNode")
13989 }
13990
13991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
13992 where
13993 V: serde::de::MapAccess<'de>,
13994 {
13995 let mut state_table__ = None;
13996 let mut sort_column_index__ = None;
13997 while let Some(k) = map_.next_key()? {
13998 match k {
13999 GeneratedField::StateTable => {
14000 if state_table__.is_some() {
14001 return Err(serde::de::Error::duplicate_field("stateTable"));
14002 }
14003 state_table__ = map_.next_value()?;
14004 }
14005 GeneratedField::SortColumnIndex => {
14006 if sort_column_index__.is_some() {
14007 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
14008 }
14009 sort_column_index__ =
14010 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14011 ;
14012 }
14013 }
14014 }
14015 Ok(SortNode {
14016 state_table: state_table__,
14017 sort_column_index: sort_column_index__.unwrap_or_default(),
14018 })
14019 }
14020 }
14021 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
14022 }
14023}
14024impl serde::Serialize for SourceBackfillNode {
14025 #[allow(deprecated)]
14026 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14027 where
14028 S: serde::Serializer,
14029 {
14030 use serde::ser::SerializeStruct;
14031 let mut len = 0;
14032 if self.upstream_source_id != 0 {
14033 len += 1;
14034 }
14035 if self.row_id_index.is_some() {
14036 len += 1;
14037 }
14038 if !self.columns.is_empty() {
14039 len += 1;
14040 }
14041 if self.info.is_some() {
14042 len += 1;
14043 }
14044 if !self.source_name.is_empty() {
14045 len += 1;
14046 }
14047 if !self.with_properties.is_empty() {
14048 len += 1;
14049 }
14050 if self.rate_limit.is_some() {
14051 len += 1;
14052 }
14053 if self.state_table.is_some() {
14054 len += 1;
14055 }
14056 if !self.secret_refs.is_empty() {
14057 len += 1;
14058 }
14059 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
14060 if self.upstream_source_id != 0 {
14061 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
14062 }
14063 if let Some(v) = self.row_id_index.as_ref() {
14064 struct_ser.serialize_field("rowIdIndex", v)?;
14065 }
14066 if !self.columns.is_empty() {
14067 struct_ser.serialize_field("columns", &self.columns)?;
14068 }
14069 if let Some(v) = self.info.as_ref() {
14070 struct_ser.serialize_field("info", v)?;
14071 }
14072 if !self.source_name.is_empty() {
14073 struct_ser.serialize_field("sourceName", &self.source_name)?;
14074 }
14075 if !self.with_properties.is_empty() {
14076 struct_ser.serialize_field("withProperties", &self.with_properties)?;
14077 }
14078 if let Some(v) = self.rate_limit.as_ref() {
14079 struct_ser.serialize_field("rateLimit", v)?;
14080 }
14081 if let Some(v) = self.state_table.as_ref() {
14082 struct_ser.serialize_field("stateTable", v)?;
14083 }
14084 if !self.secret_refs.is_empty() {
14085 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
14086 }
14087 struct_ser.end()
14088 }
14089}
14090impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
14091 #[allow(deprecated)]
14092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14093 where
14094 D: serde::Deserializer<'de>,
14095 {
14096 const FIELDS: &[&str] = &[
14097 "upstream_source_id",
14098 "upstreamSourceId",
14099 "row_id_index",
14100 "rowIdIndex",
14101 "columns",
14102 "info",
14103 "source_name",
14104 "sourceName",
14105 "with_properties",
14106 "withProperties",
14107 "rate_limit",
14108 "rateLimit",
14109 "state_table",
14110 "stateTable",
14111 "secret_refs",
14112 "secretRefs",
14113 ];
14114
14115 #[allow(clippy::enum_variant_names)]
14116 enum GeneratedField {
14117 UpstreamSourceId,
14118 RowIdIndex,
14119 Columns,
14120 Info,
14121 SourceName,
14122 WithProperties,
14123 RateLimit,
14124 StateTable,
14125 SecretRefs,
14126 }
14127 impl<'de> serde::Deserialize<'de> for GeneratedField {
14128 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14129 where
14130 D: serde::Deserializer<'de>,
14131 {
14132 struct GeneratedVisitor;
14133
14134 impl serde::de::Visitor<'_> for GeneratedVisitor {
14135 type Value = GeneratedField;
14136
14137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14138 write!(formatter, "expected one of: {:?}", &FIELDS)
14139 }
14140
14141 #[allow(unused_variables)]
14142 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14143 where
14144 E: serde::de::Error,
14145 {
14146 match value {
14147 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
14148 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
14149 "columns" => Ok(GeneratedField::Columns),
14150 "info" => Ok(GeneratedField::Info),
14151 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
14152 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
14153 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14154 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14155 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
14156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14157 }
14158 }
14159 }
14160 deserializer.deserialize_identifier(GeneratedVisitor)
14161 }
14162 }
14163 struct GeneratedVisitor;
14164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14165 type Value = SourceBackfillNode;
14166
14167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14168 formatter.write_str("struct stream_plan.SourceBackfillNode")
14169 }
14170
14171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
14172 where
14173 V: serde::de::MapAccess<'de>,
14174 {
14175 let mut upstream_source_id__ = None;
14176 let mut row_id_index__ = None;
14177 let mut columns__ = None;
14178 let mut info__ = None;
14179 let mut source_name__ = None;
14180 let mut with_properties__ = None;
14181 let mut rate_limit__ = None;
14182 let mut state_table__ = None;
14183 let mut secret_refs__ = None;
14184 while let Some(k) = map_.next_key()? {
14185 match k {
14186 GeneratedField::UpstreamSourceId => {
14187 if upstream_source_id__.is_some() {
14188 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
14189 }
14190 upstream_source_id__ =
14191 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14192 ;
14193 }
14194 GeneratedField::RowIdIndex => {
14195 if row_id_index__.is_some() {
14196 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
14197 }
14198 row_id_index__ =
14199 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14200 ;
14201 }
14202 GeneratedField::Columns => {
14203 if columns__.is_some() {
14204 return Err(serde::de::Error::duplicate_field("columns"));
14205 }
14206 columns__ = Some(map_.next_value()?);
14207 }
14208 GeneratedField::Info => {
14209 if info__.is_some() {
14210 return Err(serde::de::Error::duplicate_field("info"));
14211 }
14212 info__ = map_.next_value()?;
14213 }
14214 GeneratedField::SourceName => {
14215 if source_name__.is_some() {
14216 return Err(serde::de::Error::duplicate_field("sourceName"));
14217 }
14218 source_name__ = Some(map_.next_value()?);
14219 }
14220 GeneratedField::WithProperties => {
14221 if with_properties__.is_some() {
14222 return Err(serde::de::Error::duplicate_field("withProperties"));
14223 }
14224 with_properties__ = Some(
14225 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14226 );
14227 }
14228 GeneratedField::RateLimit => {
14229 if rate_limit__.is_some() {
14230 return Err(serde::de::Error::duplicate_field("rateLimit"));
14231 }
14232 rate_limit__ =
14233 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14234 ;
14235 }
14236 GeneratedField::StateTable => {
14237 if state_table__.is_some() {
14238 return Err(serde::de::Error::duplicate_field("stateTable"));
14239 }
14240 state_table__ = map_.next_value()?;
14241 }
14242 GeneratedField::SecretRefs => {
14243 if secret_refs__.is_some() {
14244 return Err(serde::de::Error::duplicate_field("secretRefs"));
14245 }
14246 secret_refs__ = Some(
14247 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14248 );
14249 }
14250 }
14251 }
14252 Ok(SourceBackfillNode {
14253 upstream_source_id: upstream_source_id__.unwrap_or_default(),
14254 row_id_index: row_id_index__,
14255 columns: columns__.unwrap_or_default(),
14256 info: info__,
14257 source_name: source_name__.unwrap_or_default(),
14258 with_properties: with_properties__.unwrap_or_default(),
14259 rate_limit: rate_limit__,
14260 state_table: state_table__,
14261 secret_refs: secret_refs__.unwrap_or_default(),
14262 })
14263 }
14264 }
14265 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
14266 }
14267}
14268impl serde::Serialize for SourceChangeSplitMutation {
14269 #[allow(deprecated)]
14270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14271 where
14272 S: serde::Serializer,
14273 {
14274 use serde::ser::SerializeStruct;
14275 let mut len = 0;
14276 if !self.actor_splits.is_empty() {
14277 len += 1;
14278 }
14279 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
14280 if !self.actor_splits.is_empty() {
14281 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14282 }
14283 struct_ser.end()
14284 }
14285}
14286impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
14287 #[allow(deprecated)]
14288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14289 where
14290 D: serde::Deserializer<'de>,
14291 {
14292 const FIELDS: &[&str] = &[
14293 "actor_splits",
14294 "actorSplits",
14295 ];
14296
14297 #[allow(clippy::enum_variant_names)]
14298 enum GeneratedField {
14299 ActorSplits,
14300 }
14301 impl<'de> serde::Deserialize<'de> for GeneratedField {
14302 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14303 where
14304 D: serde::Deserializer<'de>,
14305 {
14306 struct GeneratedVisitor;
14307
14308 impl serde::de::Visitor<'_> for GeneratedVisitor {
14309 type Value = GeneratedField;
14310
14311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14312 write!(formatter, "expected one of: {:?}", &FIELDS)
14313 }
14314
14315 #[allow(unused_variables)]
14316 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14317 where
14318 E: serde::de::Error,
14319 {
14320 match value {
14321 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14323 }
14324 }
14325 }
14326 deserializer.deserialize_identifier(GeneratedVisitor)
14327 }
14328 }
14329 struct GeneratedVisitor;
14330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14331 type Value = SourceChangeSplitMutation;
14332
14333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14334 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
14335 }
14336
14337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
14338 where
14339 V: serde::de::MapAccess<'de>,
14340 {
14341 let mut actor_splits__ = None;
14342 while let Some(k) = map_.next_key()? {
14343 match k {
14344 GeneratedField::ActorSplits => {
14345 if actor_splits__.is_some() {
14346 return Err(serde::de::Error::duplicate_field("actorSplits"));
14347 }
14348 actor_splits__ = Some(
14349 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14350 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14351 );
14352 }
14353 }
14354 }
14355 Ok(SourceChangeSplitMutation {
14356 actor_splits: actor_splits__.unwrap_or_default(),
14357 })
14358 }
14359 }
14360 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
14361 }
14362}
14363impl serde::Serialize for SourceNode {
14364 #[allow(deprecated)]
14365 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14366 where
14367 S: serde::Serializer,
14368 {
14369 use serde::ser::SerializeStruct;
14370 let mut len = 0;
14371 if self.source_inner.is_some() {
14372 len += 1;
14373 }
14374 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
14375 if let Some(v) = self.source_inner.as_ref() {
14376 struct_ser.serialize_field("sourceInner", v)?;
14377 }
14378 struct_ser.end()
14379 }
14380}
14381impl<'de> serde::Deserialize<'de> for SourceNode {
14382 #[allow(deprecated)]
14383 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14384 where
14385 D: serde::Deserializer<'de>,
14386 {
14387 const FIELDS: &[&str] = &[
14388 "source_inner",
14389 "sourceInner",
14390 ];
14391
14392 #[allow(clippy::enum_variant_names)]
14393 enum GeneratedField {
14394 SourceInner,
14395 }
14396 impl<'de> serde::Deserialize<'de> for GeneratedField {
14397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14398 where
14399 D: serde::Deserializer<'de>,
14400 {
14401 struct GeneratedVisitor;
14402
14403 impl serde::de::Visitor<'_> for GeneratedVisitor {
14404 type Value = GeneratedField;
14405
14406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14407 write!(formatter, "expected one of: {:?}", &FIELDS)
14408 }
14409
14410 #[allow(unused_variables)]
14411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14412 where
14413 E: serde::de::Error,
14414 {
14415 match value {
14416 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
14417 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14418 }
14419 }
14420 }
14421 deserializer.deserialize_identifier(GeneratedVisitor)
14422 }
14423 }
14424 struct GeneratedVisitor;
14425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14426 type Value = SourceNode;
14427
14428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14429 formatter.write_str("struct stream_plan.SourceNode")
14430 }
14431
14432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
14433 where
14434 V: serde::de::MapAccess<'de>,
14435 {
14436 let mut source_inner__ = None;
14437 while let Some(k) = map_.next_key()? {
14438 match k {
14439 GeneratedField::SourceInner => {
14440 if source_inner__.is_some() {
14441 return Err(serde::de::Error::duplicate_field("sourceInner"));
14442 }
14443 source_inner__ = map_.next_value()?;
14444 }
14445 }
14446 }
14447 Ok(SourceNode {
14448 source_inner: source_inner__,
14449 })
14450 }
14451 }
14452 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
14453 }
14454}
14455impl serde::Serialize for StartFragmentBackfillMutation {
14456 #[allow(deprecated)]
14457 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14458 where
14459 S: serde::Serializer,
14460 {
14461 use serde::ser::SerializeStruct;
14462 let mut len = 0;
14463 if !self.fragment_ids.is_empty() {
14464 len += 1;
14465 }
14466 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
14467 if !self.fragment_ids.is_empty() {
14468 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
14469 }
14470 struct_ser.end()
14471 }
14472}
14473impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
14474 #[allow(deprecated)]
14475 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14476 where
14477 D: serde::Deserializer<'de>,
14478 {
14479 const FIELDS: &[&str] = &[
14480 "fragment_ids",
14481 "fragmentIds",
14482 ];
14483
14484 #[allow(clippy::enum_variant_names)]
14485 enum GeneratedField {
14486 FragmentIds,
14487 }
14488 impl<'de> serde::Deserialize<'de> for GeneratedField {
14489 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14490 where
14491 D: serde::Deserializer<'de>,
14492 {
14493 struct GeneratedVisitor;
14494
14495 impl serde::de::Visitor<'_> for GeneratedVisitor {
14496 type Value = GeneratedField;
14497
14498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14499 write!(formatter, "expected one of: {:?}", &FIELDS)
14500 }
14501
14502 #[allow(unused_variables)]
14503 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14504 where
14505 E: serde::de::Error,
14506 {
14507 match value {
14508 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
14509 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14510 }
14511 }
14512 }
14513 deserializer.deserialize_identifier(GeneratedVisitor)
14514 }
14515 }
14516 struct GeneratedVisitor;
14517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14518 type Value = StartFragmentBackfillMutation;
14519
14520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14521 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
14522 }
14523
14524 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
14525 where
14526 V: serde::de::MapAccess<'de>,
14527 {
14528 let mut fragment_ids__ = None;
14529 while let Some(k) = map_.next_key()? {
14530 match k {
14531 GeneratedField::FragmentIds => {
14532 if fragment_ids__.is_some() {
14533 return Err(serde::de::Error::duplicate_field("fragmentIds"));
14534 }
14535 fragment_ids__ =
14536 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14537 .into_iter().map(|x| x.0).collect())
14538 ;
14539 }
14540 }
14541 }
14542 Ok(StartFragmentBackfillMutation {
14543 fragment_ids: fragment_ids__.unwrap_or_default(),
14544 })
14545 }
14546 }
14547 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
14548 }
14549}
14550impl serde::Serialize for StopMutation {
14551 #[allow(deprecated)]
14552 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14553 where
14554 S: serde::Serializer,
14555 {
14556 use serde::ser::SerializeStruct;
14557 let mut len = 0;
14558 if !self.actors.is_empty() {
14559 len += 1;
14560 }
14561 if !self.dropped_sink_fragments.is_empty() {
14562 len += 1;
14563 }
14564 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
14565 if !self.actors.is_empty() {
14566 struct_ser.serialize_field("actors", &self.actors)?;
14567 }
14568 if !self.dropped_sink_fragments.is_empty() {
14569 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
14570 }
14571 struct_ser.end()
14572 }
14573}
14574impl<'de> serde::Deserialize<'de> for StopMutation {
14575 #[allow(deprecated)]
14576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14577 where
14578 D: serde::Deserializer<'de>,
14579 {
14580 const FIELDS: &[&str] = &[
14581 "actors",
14582 "dropped_sink_fragments",
14583 "droppedSinkFragments",
14584 ];
14585
14586 #[allow(clippy::enum_variant_names)]
14587 enum GeneratedField {
14588 Actors,
14589 DroppedSinkFragments,
14590 }
14591 impl<'de> serde::Deserialize<'de> for GeneratedField {
14592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14593 where
14594 D: serde::Deserializer<'de>,
14595 {
14596 struct GeneratedVisitor;
14597
14598 impl serde::de::Visitor<'_> for GeneratedVisitor {
14599 type Value = GeneratedField;
14600
14601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14602 write!(formatter, "expected one of: {:?}", &FIELDS)
14603 }
14604
14605 #[allow(unused_variables)]
14606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14607 where
14608 E: serde::de::Error,
14609 {
14610 match value {
14611 "actors" => Ok(GeneratedField::Actors),
14612 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
14613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14614 }
14615 }
14616 }
14617 deserializer.deserialize_identifier(GeneratedVisitor)
14618 }
14619 }
14620 struct GeneratedVisitor;
14621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14622 type Value = StopMutation;
14623
14624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14625 formatter.write_str("struct stream_plan.StopMutation")
14626 }
14627
14628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
14629 where
14630 V: serde::de::MapAccess<'de>,
14631 {
14632 let mut actors__ = None;
14633 let mut dropped_sink_fragments__ = None;
14634 while let Some(k) = map_.next_key()? {
14635 match k {
14636 GeneratedField::Actors => {
14637 if actors__.is_some() {
14638 return Err(serde::de::Error::duplicate_field("actors"));
14639 }
14640 actors__ =
14641 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14642 .into_iter().map(|x| x.0).collect())
14643 ;
14644 }
14645 GeneratedField::DroppedSinkFragments => {
14646 if dropped_sink_fragments__.is_some() {
14647 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
14648 }
14649 dropped_sink_fragments__ =
14650 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14651 .into_iter().map(|x| x.0).collect())
14652 ;
14653 }
14654 }
14655 }
14656 Ok(StopMutation {
14657 actors: actors__.unwrap_or_default(),
14658 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
14659 })
14660 }
14661 }
14662 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
14663 }
14664}
14665impl serde::Serialize for StreamActor {
14666 #[allow(deprecated)]
14667 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14668 where
14669 S: serde::Serializer,
14670 {
14671 use serde::ser::SerializeStruct;
14672 let mut len = 0;
14673 if self.actor_id != 0 {
14674 len += 1;
14675 }
14676 if self.fragment_id != 0 {
14677 len += 1;
14678 }
14679 if !self.dispatcher.is_empty() {
14680 len += 1;
14681 }
14682 if self.vnode_bitmap.is_some() {
14683 len += 1;
14684 }
14685 if !self.mview_definition.is_empty() {
14686 len += 1;
14687 }
14688 if self.expr_context.is_some() {
14689 len += 1;
14690 }
14691 if !self.config_override.is_empty() {
14692 len += 1;
14693 }
14694 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
14695 if self.actor_id != 0 {
14696 struct_ser.serialize_field("actorId", &self.actor_id)?;
14697 }
14698 if self.fragment_id != 0 {
14699 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
14700 }
14701 if !self.dispatcher.is_empty() {
14702 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
14703 }
14704 if let Some(v) = self.vnode_bitmap.as_ref() {
14705 struct_ser.serialize_field("vnodeBitmap", v)?;
14706 }
14707 if !self.mview_definition.is_empty() {
14708 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
14709 }
14710 if let Some(v) = self.expr_context.as_ref() {
14711 struct_ser.serialize_field("exprContext", v)?;
14712 }
14713 if !self.config_override.is_empty() {
14714 struct_ser.serialize_field("configOverride", &self.config_override)?;
14715 }
14716 struct_ser.end()
14717 }
14718}
14719impl<'de> serde::Deserialize<'de> for StreamActor {
14720 #[allow(deprecated)]
14721 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14722 where
14723 D: serde::Deserializer<'de>,
14724 {
14725 const FIELDS: &[&str] = &[
14726 "actor_id",
14727 "actorId",
14728 "fragment_id",
14729 "fragmentId",
14730 "dispatcher",
14731 "vnode_bitmap",
14732 "vnodeBitmap",
14733 "mview_definition",
14734 "mviewDefinition",
14735 "expr_context",
14736 "exprContext",
14737 "config_override",
14738 "configOverride",
14739 ];
14740
14741 #[allow(clippy::enum_variant_names)]
14742 enum GeneratedField {
14743 ActorId,
14744 FragmentId,
14745 Dispatcher,
14746 VnodeBitmap,
14747 MviewDefinition,
14748 ExprContext,
14749 ConfigOverride,
14750 }
14751 impl<'de> serde::Deserialize<'de> for GeneratedField {
14752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14753 where
14754 D: serde::Deserializer<'de>,
14755 {
14756 struct GeneratedVisitor;
14757
14758 impl serde::de::Visitor<'_> for GeneratedVisitor {
14759 type Value = GeneratedField;
14760
14761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14762 write!(formatter, "expected one of: {:?}", &FIELDS)
14763 }
14764
14765 #[allow(unused_variables)]
14766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14767 where
14768 E: serde::de::Error,
14769 {
14770 match value {
14771 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14772 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
14773 "dispatcher" => Ok(GeneratedField::Dispatcher),
14774 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
14775 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
14776 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
14777 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
14778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14779 }
14780 }
14781 }
14782 deserializer.deserialize_identifier(GeneratedVisitor)
14783 }
14784 }
14785 struct GeneratedVisitor;
14786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14787 type Value = StreamActor;
14788
14789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14790 formatter.write_str("struct stream_plan.StreamActor")
14791 }
14792
14793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
14794 where
14795 V: serde::de::MapAccess<'de>,
14796 {
14797 let mut actor_id__ = None;
14798 let mut fragment_id__ = None;
14799 let mut dispatcher__ = None;
14800 let mut vnode_bitmap__ = None;
14801 let mut mview_definition__ = None;
14802 let mut expr_context__ = None;
14803 let mut config_override__ = None;
14804 while let Some(k) = map_.next_key()? {
14805 match k {
14806 GeneratedField::ActorId => {
14807 if actor_id__.is_some() {
14808 return Err(serde::de::Error::duplicate_field("actorId"));
14809 }
14810 actor_id__ =
14811 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14812 ;
14813 }
14814 GeneratedField::FragmentId => {
14815 if fragment_id__.is_some() {
14816 return Err(serde::de::Error::duplicate_field("fragmentId"));
14817 }
14818 fragment_id__ =
14819 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14820 ;
14821 }
14822 GeneratedField::Dispatcher => {
14823 if dispatcher__.is_some() {
14824 return Err(serde::de::Error::duplicate_field("dispatcher"));
14825 }
14826 dispatcher__ = Some(map_.next_value()?);
14827 }
14828 GeneratedField::VnodeBitmap => {
14829 if vnode_bitmap__.is_some() {
14830 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
14831 }
14832 vnode_bitmap__ = map_.next_value()?;
14833 }
14834 GeneratedField::MviewDefinition => {
14835 if mview_definition__.is_some() {
14836 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
14837 }
14838 mview_definition__ = Some(map_.next_value()?);
14839 }
14840 GeneratedField::ExprContext => {
14841 if expr_context__.is_some() {
14842 return Err(serde::de::Error::duplicate_field("exprContext"));
14843 }
14844 expr_context__ = map_.next_value()?;
14845 }
14846 GeneratedField::ConfigOverride => {
14847 if config_override__.is_some() {
14848 return Err(serde::de::Error::duplicate_field("configOverride"));
14849 }
14850 config_override__ = Some(map_.next_value()?);
14851 }
14852 }
14853 }
14854 Ok(StreamActor {
14855 actor_id: actor_id__.unwrap_or_default(),
14856 fragment_id: fragment_id__.unwrap_or_default(),
14857 dispatcher: dispatcher__.unwrap_or_default(),
14858 vnode_bitmap: vnode_bitmap__,
14859 mview_definition: mview_definition__.unwrap_or_default(),
14860 expr_context: expr_context__,
14861 config_override: config_override__.unwrap_or_default(),
14862 })
14863 }
14864 }
14865 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
14866 }
14867}
14868impl serde::Serialize for StreamCdcScanNode {
14869 #[allow(deprecated)]
14870 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14871 where
14872 S: serde::Serializer,
14873 {
14874 use serde::ser::SerializeStruct;
14875 let mut len = 0;
14876 if self.table_id != 0 {
14877 len += 1;
14878 }
14879 if !self.upstream_column_ids.is_empty() {
14880 len += 1;
14881 }
14882 if !self.output_indices.is_empty() {
14883 len += 1;
14884 }
14885 if self.state_table.is_some() {
14886 len += 1;
14887 }
14888 if self.cdc_table_desc.is_some() {
14889 len += 1;
14890 }
14891 if self.rate_limit.is_some() {
14892 len += 1;
14893 }
14894 if self.disable_backfill {
14895 len += 1;
14896 }
14897 if self.options.is_some() {
14898 len += 1;
14899 }
14900 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
14901 if self.table_id != 0 {
14902 struct_ser.serialize_field("tableId", &self.table_id)?;
14903 }
14904 if !self.upstream_column_ids.is_empty() {
14905 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
14906 }
14907 if !self.output_indices.is_empty() {
14908 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14909 }
14910 if let Some(v) = self.state_table.as_ref() {
14911 struct_ser.serialize_field("stateTable", v)?;
14912 }
14913 if let Some(v) = self.cdc_table_desc.as_ref() {
14914 struct_ser.serialize_field("cdcTableDesc", v)?;
14915 }
14916 if let Some(v) = self.rate_limit.as_ref() {
14917 struct_ser.serialize_field("rateLimit", v)?;
14918 }
14919 if self.disable_backfill {
14920 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
14921 }
14922 if let Some(v) = self.options.as_ref() {
14923 struct_ser.serialize_field("options", v)?;
14924 }
14925 struct_ser.end()
14926 }
14927}
14928impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
14929 #[allow(deprecated)]
14930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14931 where
14932 D: serde::Deserializer<'de>,
14933 {
14934 const FIELDS: &[&str] = &[
14935 "table_id",
14936 "tableId",
14937 "upstream_column_ids",
14938 "upstreamColumnIds",
14939 "output_indices",
14940 "outputIndices",
14941 "state_table",
14942 "stateTable",
14943 "cdc_table_desc",
14944 "cdcTableDesc",
14945 "rate_limit",
14946 "rateLimit",
14947 "disable_backfill",
14948 "disableBackfill",
14949 "options",
14950 ];
14951
14952 #[allow(clippy::enum_variant_names)]
14953 enum GeneratedField {
14954 TableId,
14955 UpstreamColumnIds,
14956 OutputIndices,
14957 StateTable,
14958 CdcTableDesc,
14959 RateLimit,
14960 DisableBackfill,
14961 Options,
14962 }
14963 impl<'de> serde::Deserialize<'de> for GeneratedField {
14964 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14965 where
14966 D: serde::Deserializer<'de>,
14967 {
14968 struct GeneratedVisitor;
14969
14970 impl serde::de::Visitor<'_> for GeneratedVisitor {
14971 type Value = GeneratedField;
14972
14973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14974 write!(formatter, "expected one of: {:?}", &FIELDS)
14975 }
14976
14977 #[allow(unused_variables)]
14978 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14979 where
14980 E: serde::de::Error,
14981 {
14982 match value {
14983 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14984 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
14985 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14986 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14987 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
14988 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14989 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
14990 "options" => Ok(GeneratedField::Options),
14991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14992 }
14993 }
14994 }
14995 deserializer.deserialize_identifier(GeneratedVisitor)
14996 }
14997 }
14998 struct GeneratedVisitor;
14999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15000 type Value = StreamCdcScanNode;
15001
15002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15003 formatter.write_str("struct stream_plan.StreamCdcScanNode")
15004 }
15005
15006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
15007 where
15008 V: serde::de::MapAccess<'de>,
15009 {
15010 let mut table_id__ = None;
15011 let mut upstream_column_ids__ = None;
15012 let mut output_indices__ = None;
15013 let mut state_table__ = None;
15014 let mut cdc_table_desc__ = None;
15015 let mut rate_limit__ = None;
15016 let mut disable_backfill__ = None;
15017 let mut options__ = None;
15018 while let Some(k) = map_.next_key()? {
15019 match k {
15020 GeneratedField::TableId => {
15021 if table_id__.is_some() {
15022 return Err(serde::de::Error::duplicate_field("tableId"));
15023 }
15024 table_id__ =
15025 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15026 ;
15027 }
15028 GeneratedField::UpstreamColumnIds => {
15029 if upstream_column_ids__.is_some() {
15030 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15031 }
15032 upstream_column_ids__ =
15033 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15034 .into_iter().map(|x| x.0).collect())
15035 ;
15036 }
15037 GeneratedField::OutputIndices => {
15038 if output_indices__.is_some() {
15039 return Err(serde::de::Error::duplicate_field("outputIndices"));
15040 }
15041 output_indices__ =
15042 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15043 .into_iter().map(|x| x.0).collect())
15044 ;
15045 }
15046 GeneratedField::StateTable => {
15047 if state_table__.is_some() {
15048 return Err(serde::de::Error::duplicate_field("stateTable"));
15049 }
15050 state_table__ = map_.next_value()?;
15051 }
15052 GeneratedField::CdcTableDesc => {
15053 if cdc_table_desc__.is_some() {
15054 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
15055 }
15056 cdc_table_desc__ = map_.next_value()?;
15057 }
15058 GeneratedField::RateLimit => {
15059 if rate_limit__.is_some() {
15060 return Err(serde::de::Error::duplicate_field("rateLimit"));
15061 }
15062 rate_limit__ =
15063 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15064 ;
15065 }
15066 GeneratedField::DisableBackfill => {
15067 if disable_backfill__.is_some() {
15068 return Err(serde::de::Error::duplicate_field("disableBackfill"));
15069 }
15070 disable_backfill__ = Some(map_.next_value()?);
15071 }
15072 GeneratedField::Options => {
15073 if options__.is_some() {
15074 return Err(serde::de::Error::duplicate_field("options"));
15075 }
15076 options__ = map_.next_value()?;
15077 }
15078 }
15079 }
15080 Ok(StreamCdcScanNode {
15081 table_id: table_id__.unwrap_or_default(),
15082 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15083 output_indices: output_indices__.unwrap_or_default(),
15084 state_table: state_table__,
15085 cdc_table_desc: cdc_table_desc__,
15086 rate_limit: rate_limit__,
15087 disable_backfill: disable_backfill__.unwrap_or_default(),
15088 options: options__,
15089 })
15090 }
15091 }
15092 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
15093 }
15094}
15095impl serde::Serialize for StreamCdcScanOptions {
15096 #[allow(deprecated)]
15097 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15098 where
15099 S: serde::Serializer,
15100 {
15101 use serde::ser::SerializeStruct;
15102 let mut len = 0;
15103 if self.disable_backfill {
15104 len += 1;
15105 }
15106 if self.snapshot_barrier_interval != 0 {
15107 len += 1;
15108 }
15109 if self.snapshot_batch_size != 0 {
15110 len += 1;
15111 }
15112 if self.backfill_parallelism != 0 {
15113 len += 1;
15114 }
15115 if self.backfill_num_rows_per_split != 0 {
15116 len += 1;
15117 }
15118 if self.backfill_as_even_splits {
15119 len += 1;
15120 }
15121 if self.backfill_split_pk_column_index != 0 {
15122 len += 1;
15123 }
15124 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
15125 if self.disable_backfill {
15126 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
15127 }
15128 if self.snapshot_barrier_interval != 0 {
15129 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
15130 }
15131 if self.snapshot_batch_size != 0 {
15132 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
15133 }
15134 if self.backfill_parallelism != 0 {
15135 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
15136 }
15137 if self.backfill_num_rows_per_split != 0 {
15138 #[allow(clippy::needless_borrow)]
15139 #[allow(clippy::needless_borrows_for_generic_args)]
15140 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
15141 }
15142 if self.backfill_as_even_splits {
15143 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
15144 }
15145 if self.backfill_split_pk_column_index != 0 {
15146 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
15147 }
15148 struct_ser.end()
15149 }
15150}
15151impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
15152 #[allow(deprecated)]
15153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15154 where
15155 D: serde::Deserializer<'de>,
15156 {
15157 const FIELDS: &[&str] = &[
15158 "disable_backfill",
15159 "disableBackfill",
15160 "snapshot_barrier_interval",
15161 "snapshotBarrierInterval",
15162 "snapshot_batch_size",
15163 "snapshotBatchSize",
15164 "backfill_parallelism",
15165 "backfillParallelism",
15166 "backfill_num_rows_per_split",
15167 "backfillNumRowsPerSplit",
15168 "backfill_as_even_splits",
15169 "backfillAsEvenSplits",
15170 "backfill_split_pk_column_index",
15171 "backfillSplitPkColumnIndex",
15172 ];
15173
15174 #[allow(clippy::enum_variant_names)]
15175 enum GeneratedField {
15176 DisableBackfill,
15177 SnapshotBarrierInterval,
15178 SnapshotBatchSize,
15179 BackfillParallelism,
15180 BackfillNumRowsPerSplit,
15181 BackfillAsEvenSplits,
15182 BackfillSplitPkColumnIndex,
15183 }
15184 impl<'de> serde::Deserialize<'de> for GeneratedField {
15185 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15186 where
15187 D: serde::Deserializer<'de>,
15188 {
15189 struct GeneratedVisitor;
15190
15191 impl serde::de::Visitor<'_> for GeneratedVisitor {
15192 type Value = GeneratedField;
15193
15194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15195 write!(formatter, "expected one of: {:?}", &FIELDS)
15196 }
15197
15198 #[allow(unused_variables)]
15199 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15200 where
15201 E: serde::de::Error,
15202 {
15203 match value {
15204 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
15205 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
15206 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
15207 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
15208 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
15209 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
15210 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
15211 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15212 }
15213 }
15214 }
15215 deserializer.deserialize_identifier(GeneratedVisitor)
15216 }
15217 }
15218 struct GeneratedVisitor;
15219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15220 type Value = StreamCdcScanOptions;
15221
15222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15223 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
15224 }
15225
15226 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
15227 where
15228 V: serde::de::MapAccess<'de>,
15229 {
15230 let mut disable_backfill__ = None;
15231 let mut snapshot_barrier_interval__ = None;
15232 let mut snapshot_batch_size__ = None;
15233 let mut backfill_parallelism__ = None;
15234 let mut backfill_num_rows_per_split__ = None;
15235 let mut backfill_as_even_splits__ = None;
15236 let mut backfill_split_pk_column_index__ = None;
15237 while let Some(k) = map_.next_key()? {
15238 match k {
15239 GeneratedField::DisableBackfill => {
15240 if disable_backfill__.is_some() {
15241 return Err(serde::de::Error::duplicate_field("disableBackfill"));
15242 }
15243 disable_backfill__ = Some(map_.next_value()?);
15244 }
15245 GeneratedField::SnapshotBarrierInterval => {
15246 if snapshot_barrier_interval__.is_some() {
15247 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
15248 }
15249 snapshot_barrier_interval__ =
15250 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15251 ;
15252 }
15253 GeneratedField::SnapshotBatchSize => {
15254 if snapshot_batch_size__.is_some() {
15255 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
15256 }
15257 snapshot_batch_size__ =
15258 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15259 ;
15260 }
15261 GeneratedField::BackfillParallelism => {
15262 if backfill_parallelism__.is_some() {
15263 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
15264 }
15265 backfill_parallelism__ =
15266 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15267 ;
15268 }
15269 GeneratedField::BackfillNumRowsPerSplit => {
15270 if backfill_num_rows_per_split__.is_some() {
15271 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
15272 }
15273 backfill_num_rows_per_split__ =
15274 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15275 ;
15276 }
15277 GeneratedField::BackfillAsEvenSplits => {
15278 if backfill_as_even_splits__.is_some() {
15279 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
15280 }
15281 backfill_as_even_splits__ = Some(map_.next_value()?);
15282 }
15283 GeneratedField::BackfillSplitPkColumnIndex => {
15284 if backfill_split_pk_column_index__.is_some() {
15285 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
15286 }
15287 backfill_split_pk_column_index__ =
15288 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15289 ;
15290 }
15291 }
15292 }
15293 Ok(StreamCdcScanOptions {
15294 disable_backfill: disable_backfill__.unwrap_or_default(),
15295 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
15296 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
15297 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
15298 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
15299 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
15300 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
15301 })
15302 }
15303 }
15304 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
15305 }
15306}
15307impl serde::Serialize for StreamContext {
15308 #[allow(deprecated)]
15309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15310 where
15311 S: serde::Serializer,
15312 {
15313 use serde::ser::SerializeStruct;
15314 let mut len = 0;
15315 if !self.timezone.is_empty() {
15316 len += 1;
15317 }
15318 if !self.config_override.is_empty() {
15319 len += 1;
15320 }
15321 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
15322 if !self.timezone.is_empty() {
15323 struct_ser.serialize_field("timezone", &self.timezone)?;
15324 }
15325 if !self.config_override.is_empty() {
15326 struct_ser.serialize_field("configOverride", &self.config_override)?;
15327 }
15328 struct_ser.end()
15329 }
15330}
15331impl<'de> serde::Deserialize<'de> for StreamContext {
15332 #[allow(deprecated)]
15333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15334 where
15335 D: serde::Deserializer<'de>,
15336 {
15337 const FIELDS: &[&str] = &[
15338 "timezone",
15339 "config_override",
15340 "configOverride",
15341 ];
15342
15343 #[allow(clippy::enum_variant_names)]
15344 enum GeneratedField {
15345 Timezone,
15346 ConfigOverride,
15347 }
15348 impl<'de> serde::Deserialize<'de> for GeneratedField {
15349 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15350 where
15351 D: serde::Deserializer<'de>,
15352 {
15353 struct GeneratedVisitor;
15354
15355 impl serde::de::Visitor<'_> for GeneratedVisitor {
15356 type Value = GeneratedField;
15357
15358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15359 write!(formatter, "expected one of: {:?}", &FIELDS)
15360 }
15361
15362 #[allow(unused_variables)]
15363 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15364 where
15365 E: serde::de::Error,
15366 {
15367 match value {
15368 "timezone" => Ok(GeneratedField::Timezone),
15369 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
15370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15371 }
15372 }
15373 }
15374 deserializer.deserialize_identifier(GeneratedVisitor)
15375 }
15376 }
15377 struct GeneratedVisitor;
15378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15379 type Value = StreamContext;
15380
15381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15382 formatter.write_str("struct stream_plan.StreamContext")
15383 }
15384
15385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
15386 where
15387 V: serde::de::MapAccess<'de>,
15388 {
15389 let mut timezone__ = None;
15390 let mut config_override__ = None;
15391 while let Some(k) = map_.next_key()? {
15392 match k {
15393 GeneratedField::Timezone => {
15394 if timezone__.is_some() {
15395 return Err(serde::de::Error::duplicate_field("timezone"));
15396 }
15397 timezone__ = Some(map_.next_value()?);
15398 }
15399 GeneratedField::ConfigOverride => {
15400 if config_override__.is_some() {
15401 return Err(serde::de::Error::duplicate_field("configOverride"));
15402 }
15403 config_override__ = Some(map_.next_value()?);
15404 }
15405 }
15406 }
15407 Ok(StreamContext {
15408 timezone: timezone__.unwrap_or_default(),
15409 config_override: config_override__.unwrap_or_default(),
15410 })
15411 }
15412 }
15413 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
15414 }
15415}
15416impl serde::Serialize for StreamFragmentGraph {
15417 #[allow(deprecated)]
15418 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15419 where
15420 S: serde::Serializer,
15421 {
15422 use serde::ser::SerializeStruct;
15423 let mut len = 0;
15424 if !self.fragments.is_empty() {
15425 len += 1;
15426 }
15427 if !self.edges.is_empty() {
15428 len += 1;
15429 }
15430 if !self.dependent_table_ids.is_empty() {
15431 len += 1;
15432 }
15433 if self.table_ids_cnt != 0 {
15434 len += 1;
15435 }
15436 if self.ctx.is_some() {
15437 len += 1;
15438 }
15439 if self.parallelism.is_some() {
15440 len += 1;
15441 }
15442 if self.backfill_parallelism.is_some() {
15443 len += 1;
15444 }
15445 if !self.adaptive_parallelism_strategy.is_empty() {
15446 len += 1;
15447 }
15448 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
15449 len += 1;
15450 }
15451 if self.max_parallelism != 0 {
15452 len += 1;
15453 }
15454 if self.backfill_order.is_some() {
15455 len += 1;
15456 }
15457 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
15458 if !self.fragments.is_empty() {
15459 struct_ser.serialize_field("fragments", &self.fragments)?;
15460 }
15461 if !self.edges.is_empty() {
15462 struct_ser.serialize_field("edges", &self.edges)?;
15463 }
15464 if !self.dependent_table_ids.is_empty() {
15465 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
15466 }
15467 if self.table_ids_cnt != 0 {
15468 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
15469 }
15470 if let Some(v) = self.ctx.as_ref() {
15471 struct_ser.serialize_field("ctx", v)?;
15472 }
15473 if let Some(v) = self.parallelism.as_ref() {
15474 struct_ser.serialize_field("parallelism", v)?;
15475 }
15476 if let Some(v) = self.backfill_parallelism.as_ref() {
15477 struct_ser.serialize_field("backfillParallelism", v)?;
15478 }
15479 if !self.adaptive_parallelism_strategy.is_empty() {
15480 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
15481 }
15482 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
15483 struct_ser.serialize_field("backfillAdaptiveParallelismStrategy", &self.backfill_adaptive_parallelism_strategy)?;
15484 }
15485 if self.max_parallelism != 0 {
15486 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
15487 }
15488 if let Some(v) = self.backfill_order.as_ref() {
15489 struct_ser.serialize_field("backfillOrder", v)?;
15490 }
15491 struct_ser.end()
15492 }
15493}
15494impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
15495 #[allow(deprecated)]
15496 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15497 where
15498 D: serde::Deserializer<'de>,
15499 {
15500 const FIELDS: &[&str] = &[
15501 "fragments",
15502 "edges",
15503 "dependent_table_ids",
15504 "dependentTableIds",
15505 "table_ids_cnt",
15506 "tableIdsCnt",
15507 "ctx",
15508 "parallelism",
15509 "backfill_parallelism",
15510 "backfillParallelism",
15511 "adaptive_parallelism_strategy",
15512 "adaptiveParallelismStrategy",
15513 "backfill_adaptive_parallelism_strategy",
15514 "backfillAdaptiveParallelismStrategy",
15515 "max_parallelism",
15516 "maxParallelism",
15517 "backfill_order",
15518 "backfillOrder",
15519 ];
15520
15521 #[allow(clippy::enum_variant_names)]
15522 enum GeneratedField {
15523 Fragments,
15524 Edges,
15525 DependentTableIds,
15526 TableIdsCnt,
15527 Ctx,
15528 Parallelism,
15529 BackfillParallelism,
15530 AdaptiveParallelismStrategy,
15531 BackfillAdaptiveParallelismStrategy,
15532 MaxParallelism,
15533 BackfillOrder,
15534 }
15535 impl<'de> serde::Deserialize<'de> for GeneratedField {
15536 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15537 where
15538 D: serde::Deserializer<'de>,
15539 {
15540 struct GeneratedVisitor;
15541
15542 impl serde::de::Visitor<'_> for GeneratedVisitor {
15543 type Value = GeneratedField;
15544
15545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15546 write!(formatter, "expected one of: {:?}", &FIELDS)
15547 }
15548
15549 #[allow(unused_variables)]
15550 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15551 where
15552 E: serde::de::Error,
15553 {
15554 match value {
15555 "fragments" => Ok(GeneratedField::Fragments),
15556 "edges" => Ok(GeneratedField::Edges),
15557 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
15558 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
15559 "ctx" => Ok(GeneratedField::Ctx),
15560 "parallelism" => Ok(GeneratedField::Parallelism),
15561 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
15562 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15563 "backfillAdaptiveParallelismStrategy" | "backfill_adaptive_parallelism_strategy" => Ok(GeneratedField::BackfillAdaptiveParallelismStrategy),
15564 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15565 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
15566 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15567 }
15568 }
15569 }
15570 deserializer.deserialize_identifier(GeneratedVisitor)
15571 }
15572 }
15573 struct GeneratedVisitor;
15574 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15575 type Value = StreamFragmentGraph;
15576
15577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15578 formatter.write_str("struct stream_plan.StreamFragmentGraph")
15579 }
15580
15581 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
15582 where
15583 V: serde::de::MapAccess<'de>,
15584 {
15585 let mut fragments__ = None;
15586 let mut edges__ = None;
15587 let mut dependent_table_ids__ = None;
15588 let mut table_ids_cnt__ = None;
15589 let mut ctx__ = None;
15590 let mut parallelism__ = None;
15591 let mut backfill_parallelism__ = None;
15592 let mut adaptive_parallelism_strategy__ = None;
15593 let mut backfill_adaptive_parallelism_strategy__ = None;
15594 let mut max_parallelism__ = None;
15595 let mut backfill_order__ = None;
15596 while let Some(k) = map_.next_key()? {
15597 match k {
15598 GeneratedField::Fragments => {
15599 if fragments__.is_some() {
15600 return Err(serde::de::Error::duplicate_field("fragments"));
15601 }
15602 fragments__ = Some(
15603 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15604 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15605 );
15606 }
15607 GeneratedField::Edges => {
15608 if edges__.is_some() {
15609 return Err(serde::de::Error::duplicate_field("edges"));
15610 }
15611 edges__ = Some(map_.next_value()?);
15612 }
15613 GeneratedField::DependentTableIds => {
15614 if dependent_table_ids__.is_some() {
15615 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
15616 }
15617 dependent_table_ids__ =
15618 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15619 .into_iter().map(|x| x.0).collect())
15620 ;
15621 }
15622 GeneratedField::TableIdsCnt => {
15623 if table_ids_cnt__.is_some() {
15624 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
15625 }
15626 table_ids_cnt__ =
15627 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15628 ;
15629 }
15630 GeneratedField::Ctx => {
15631 if ctx__.is_some() {
15632 return Err(serde::de::Error::duplicate_field("ctx"));
15633 }
15634 ctx__ = map_.next_value()?;
15635 }
15636 GeneratedField::Parallelism => {
15637 if parallelism__.is_some() {
15638 return Err(serde::de::Error::duplicate_field("parallelism"));
15639 }
15640 parallelism__ = map_.next_value()?;
15641 }
15642 GeneratedField::BackfillParallelism => {
15643 if backfill_parallelism__.is_some() {
15644 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
15645 }
15646 backfill_parallelism__ = map_.next_value()?;
15647 }
15648 GeneratedField::AdaptiveParallelismStrategy => {
15649 if adaptive_parallelism_strategy__.is_some() {
15650 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15651 }
15652 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
15653 }
15654 GeneratedField::BackfillAdaptiveParallelismStrategy => {
15655 if backfill_adaptive_parallelism_strategy__.is_some() {
15656 return Err(serde::de::Error::duplicate_field("backfillAdaptiveParallelismStrategy"));
15657 }
15658 backfill_adaptive_parallelism_strategy__ = Some(map_.next_value()?);
15659 }
15660 GeneratedField::MaxParallelism => {
15661 if max_parallelism__.is_some() {
15662 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15663 }
15664 max_parallelism__ =
15665 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15666 ;
15667 }
15668 GeneratedField::BackfillOrder => {
15669 if backfill_order__.is_some() {
15670 return Err(serde::de::Error::duplicate_field("backfillOrder"));
15671 }
15672 backfill_order__ = map_.next_value()?;
15673 }
15674 }
15675 }
15676 Ok(StreamFragmentGraph {
15677 fragments: fragments__.unwrap_or_default(),
15678 edges: edges__.unwrap_or_default(),
15679 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
15680 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
15681 ctx: ctx__,
15682 parallelism: parallelism__,
15683 backfill_parallelism: backfill_parallelism__,
15684 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
15685 backfill_adaptive_parallelism_strategy: backfill_adaptive_parallelism_strategy__.unwrap_or_default(),
15686 max_parallelism: max_parallelism__.unwrap_or_default(),
15687 backfill_order: backfill_order__,
15688 })
15689 }
15690 }
15691 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
15692 }
15693}
15694impl serde::Serialize for stream_fragment_graph::Parallelism {
15695 #[allow(deprecated)]
15696 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15697 where
15698 S: serde::Serializer,
15699 {
15700 use serde::ser::SerializeStruct;
15701 let mut len = 0;
15702 if self.parallelism != 0 {
15703 len += 1;
15704 }
15705 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
15706 if self.parallelism != 0 {
15707 #[allow(clippy::needless_borrow)]
15708 #[allow(clippy::needless_borrows_for_generic_args)]
15709 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
15710 }
15711 struct_ser.end()
15712 }
15713}
15714impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
15715 #[allow(deprecated)]
15716 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15717 where
15718 D: serde::Deserializer<'de>,
15719 {
15720 const FIELDS: &[&str] = &[
15721 "parallelism",
15722 ];
15723
15724 #[allow(clippy::enum_variant_names)]
15725 enum GeneratedField {
15726 Parallelism,
15727 }
15728 impl<'de> serde::Deserialize<'de> for GeneratedField {
15729 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15730 where
15731 D: serde::Deserializer<'de>,
15732 {
15733 struct GeneratedVisitor;
15734
15735 impl serde::de::Visitor<'_> for GeneratedVisitor {
15736 type Value = GeneratedField;
15737
15738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15739 write!(formatter, "expected one of: {:?}", &FIELDS)
15740 }
15741
15742 #[allow(unused_variables)]
15743 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15744 where
15745 E: serde::de::Error,
15746 {
15747 match value {
15748 "parallelism" => Ok(GeneratedField::Parallelism),
15749 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15750 }
15751 }
15752 }
15753 deserializer.deserialize_identifier(GeneratedVisitor)
15754 }
15755 }
15756 struct GeneratedVisitor;
15757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15758 type Value = stream_fragment_graph::Parallelism;
15759
15760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15761 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
15762 }
15763
15764 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
15765 where
15766 V: serde::de::MapAccess<'de>,
15767 {
15768 let mut parallelism__ = None;
15769 while let Some(k) = map_.next_key()? {
15770 match k {
15771 GeneratedField::Parallelism => {
15772 if parallelism__.is_some() {
15773 return Err(serde::de::Error::duplicate_field("parallelism"));
15774 }
15775 parallelism__ =
15776 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15777 ;
15778 }
15779 }
15780 }
15781 Ok(stream_fragment_graph::Parallelism {
15782 parallelism: parallelism__.unwrap_or_default(),
15783 })
15784 }
15785 }
15786 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
15787 }
15788}
15789impl serde::Serialize for stream_fragment_graph::StreamFragment {
15790 #[allow(deprecated)]
15791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15792 where
15793 S: serde::Serializer,
15794 {
15795 use serde::ser::SerializeStruct;
15796 let mut len = 0;
15797 if self.fragment_id != 0 {
15798 len += 1;
15799 }
15800 if self.node.is_some() {
15801 len += 1;
15802 }
15803 if self.fragment_type_mask != 0 {
15804 len += 1;
15805 }
15806 if self.requires_singleton {
15807 len += 1;
15808 }
15809 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
15810 if self.fragment_id != 0 {
15811 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15812 }
15813 if let Some(v) = self.node.as_ref() {
15814 struct_ser.serialize_field("node", v)?;
15815 }
15816 if self.fragment_type_mask != 0 {
15817 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15818 }
15819 if self.requires_singleton {
15820 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
15821 }
15822 struct_ser.end()
15823 }
15824}
15825impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
15826 #[allow(deprecated)]
15827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15828 where
15829 D: serde::Deserializer<'de>,
15830 {
15831 const FIELDS: &[&str] = &[
15832 "fragment_id",
15833 "fragmentId",
15834 "node",
15835 "fragment_type_mask",
15836 "fragmentTypeMask",
15837 "requires_singleton",
15838 "requiresSingleton",
15839 ];
15840
15841 #[allow(clippy::enum_variant_names)]
15842 enum GeneratedField {
15843 FragmentId,
15844 Node,
15845 FragmentTypeMask,
15846 RequiresSingleton,
15847 }
15848 impl<'de> serde::Deserialize<'de> for GeneratedField {
15849 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15850 where
15851 D: serde::Deserializer<'de>,
15852 {
15853 struct GeneratedVisitor;
15854
15855 impl serde::de::Visitor<'_> for GeneratedVisitor {
15856 type Value = GeneratedField;
15857
15858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15859 write!(formatter, "expected one of: {:?}", &FIELDS)
15860 }
15861
15862 #[allow(unused_variables)]
15863 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15864 where
15865 E: serde::de::Error,
15866 {
15867 match value {
15868 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
15869 "node" => Ok(GeneratedField::Node),
15870 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
15871 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
15872 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15873 }
15874 }
15875 }
15876 deserializer.deserialize_identifier(GeneratedVisitor)
15877 }
15878 }
15879 struct GeneratedVisitor;
15880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15881 type Value = stream_fragment_graph::StreamFragment;
15882
15883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15884 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
15885 }
15886
15887 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
15888 where
15889 V: serde::de::MapAccess<'de>,
15890 {
15891 let mut fragment_id__ = None;
15892 let mut node__ = None;
15893 let mut fragment_type_mask__ = None;
15894 let mut requires_singleton__ = None;
15895 while let Some(k) = map_.next_key()? {
15896 match k {
15897 GeneratedField::FragmentId => {
15898 if fragment_id__.is_some() {
15899 return Err(serde::de::Error::duplicate_field("fragmentId"));
15900 }
15901 fragment_id__ =
15902 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15903 ;
15904 }
15905 GeneratedField::Node => {
15906 if node__.is_some() {
15907 return Err(serde::de::Error::duplicate_field("node"));
15908 }
15909 node__ = map_.next_value()?;
15910 }
15911 GeneratedField::FragmentTypeMask => {
15912 if fragment_type_mask__.is_some() {
15913 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
15914 }
15915 fragment_type_mask__ =
15916 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15917 ;
15918 }
15919 GeneratedField::RequiresSingleton => {
15920 if requires_singleton__.is_some() {
15921 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
15922 }
15923 requires_singleton__ = Some(map_.next_value()?);
15924 }
15925 }
15926 }
15927 Ok(stream_fragment_graph::StreamFragment {
15928 fragment_id: fragment_id__.unwrap_or_default(),
15929 node: node__,
15930 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
15931 requires_singleton: requires_singleton__.unwrap_or_default(),
15932 })
15933 }
15934 }
15935 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
15936 }
15937}
15938impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
15939 #[allow(deprecated)]
15940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15941 where
15942 S: serde::Serializer,
15943 {
15944 use serde::ser::SerializeStruct;
15945 let mut len = 0;
15946 if self.dispatch_strategy.is_some() {
15947 len += 1;
15948 }
15949 if self.link_id != 0 {
15950 len += 1;
15951 }
15952 if self.upstream_id != 0 {
15953 len += 1;
15954 }
15955 if self.downstream_id != 0 {
15956 len += 1;
15957 }
15958 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
15959 if let Some(v) = self.dispatch_strategy.as_ref() {
15960 struct_ser.serialize_field("dispatchStrategy", v)?;
15961 }
15962 if self.link_id != 0 {
15963 #[allow(clippy::needless_borrow)]
15964 #[allow(clippy::needless_borrows_for_generic_args)]
15965 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
15966 }
15967 if self.upstream_id != 0 {
15968 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
15969 }
15970 if self.downstream_id != 0 {
15971 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
15972 }
15973 struct_ser.end()
15974 }
15975}
15976impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
15977 #[allow(deprecated)]
15978 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15979 where
15980 D: serde::Deserializer<'de>,
15981 {
15982 const FIELDS: &[&str] = &[
15983 "dispatch_strategy",
15984 "dispatchStrategy",
15985 "link_id",
15986 "linkId",
15987 "upstream_id",
15988 "upstreamId",
15989 "downstream_id",
15990 "downstreamId",
15991 ];
15992
15993 #[allow(clippy::enum_variant_names)]
15994 enum GeneratedField {
15995 DispatchStrategy,
15996 LinkId,
15997 UpstreamId,
15998 DownstreamId,
15999 }
16000 impl<'de> serde::Deserialize<'de> for GeneratedField {
16001 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16002 where
16003 D: serde::Deserializer<'de>,
16004 {
16005 struct GeneratedVisitor;
16006
16007 impl serde::de::Visitor<'_> for GeneratedVisitor {
16008 type Value = GeneratedField;
16009
16010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16011 write!(formatter, "expected one of: {:?}", &FIELDS)
16012 }
16013
16014 #[allow(unused_variables)]
16015 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16016 where
16017 E: serde::de::Error,
16018 {
16019 match value {
16020 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
16021 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
16022 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
16023 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
16024 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16025 }
16026 }
16027 }
16028 deserializer.deserialize_identifier(GeneratedVisitor)
16029 }
16030 }
16031 struct GeneratedVisitor;
16032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16033 type Value = stream_fragment_graph::StreamFragmentEdge;
16034
16035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16036 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
16037 }
16038
16039 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
16040 where
16041 V: serde::de::MapAccess<'de>,
16042 {
16043 let mut dispatch_strategy__ = None;
16044 let mut link_id__ = None;
16045 let mut upstream_id__ = None;
16046 let mut downstream_id__ = None;
16047 while let Some(k) = map_.next_key()? {
16048 match k {
16049 GeneratedField::DispatchStrategy => {
16050 if dispatch_strategy__.is_some() {
16051 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
16052 }
16053 dispatch_strategy__ = map_.next_value()?;
16054 }
16055 GeneratedField::LinkId => {
16056 if link_id__.is_some() {
16057 return Err(serde::de::Error::duplicate_field("linkId"));
16058 }
16059 link_id__ =
16060 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16061 ;
16062 }
16063 GeneratedField::UpstreamId => {
16064 if upstream_id__.is_some() {
16065 return Err(serde::de::Error::duplicate_field("upstreamId"));
16066 }
16067 upstream_id__ =
16068 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16069 ;
16070 }
16071 GeneratedField::DownstreamId => {
16072 if downstream_id__.is_some() {
16073 return Err(serde::de::Error::duplicate_field("downstreamId"));
16074 }
16075 downstream_id__ =
16076 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16077 ;
16078 }
16079 }
16080 }
16081 Ok(stream_fragment_graph::StreamFragmentEdge {
16082 dispatch_strategy: dispatch_strategy__,
16083 link_id: link_id__.unwrap_or_default(),
16084 upstream_id: upstream_id__.unwrap_or_default(),
16085 downstream_id: downstream_id__.unwrap_or_default(),
16086 })
16087 }
16088 }
16089 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
16090 }
16091}
16092impl serde::Serialize for StreamFsFetch {
16093 #[allow(deprecated)]
16094 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16095 where
16096 S: serde::Serializer,
16097 {
16098 use serde::ser::SerializeStruct;
16099 let mut len = 0;
16100 if self.source_id != 0 {
16101 len += 1;
16102 }
16103 if self.state_table.is_some() {
16104 len += 1;
16105 }
16106 if self.row_id_index.is_some() {
16107 len += 1;
16108 }
16109 if !self.columns.is_empty() {
16110 len += 1;
16111 }
16112 if !self.with_properties.is_empty() {
16113 len += 1;
16114 }
16115 if self.info.is_some() {
16116 len += 1;
16117 }
16118 if !self.source_name.is_empty() {
16119 len += 1;
16120 }
16121 if self.rate_limit.is_some() {
16122 len += 1;
16123 }
16124 if !self.secret_refs.is_empty() {
16125 len += 1;
16126 }
16127 if self.refresh_mode.is_some() {
16128 len += 1;
16129 }
16130 if self.associated_table_id.is_some() {
16131 len += 1;
16132 }
16133 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
16134 if self.source_id != 0 {
16135 struct_ser.serialize_field("sourceId", &self.source_id)?;
16136 }
16137 if let Some(v) = self.state_table.as_ref() {
16138 struct_ser.serialize_field("stateTable", v)?;
16139 }
16140 if let Some(v) = self.row_id_index.as_ref() {
16141 struct_ser.serialize_field("rowIdIndex", v)?;
16142 }
16143 if !self.columns.is_empty() {
16144 struct_ser.serialize_field("columns", &self.columns)?;
16145 }
16146 if !self.with_properties.is_empty() {
16147 struct_ser.serialize_field("withProperties", &self.with_properties)?;
16148 }
16149 if let Some(v) = self.info.as_ref() {
16150 struct_ser.serialize_field("info", v)?;
16151 }
16152 if !self.source_name.is_empty() {
16153 struct_ser.serialize_field("sourceName", &self.source_name)?;
16154 }
16155 if let Some(v) = self.rate_limit.as_ref() {
16156 struct_ser.serialize_field("rateLimit", v)?;
16157 }
16158 if !self.secret_refs.is_empty() {
16159 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
16160 }
16161 if let Some(v) = self.refresh_mode.as_ref() {
16162 struct_ser.serialize_field("refreshMode", v)?;
16163 }
16164 if let Some(v) = self.associated_table_id.as_ref() {
16165 struct_ser.serialize_field("associatedTableId", v)?;
16166 }
16167 struct_ser.end()
16168 }
16169}
16170impl<'de> serde::Deserialize<'de> for StreamFsFetch {
16171 #[allow(deprecated)]
16172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16173 where
16174 D: serde::Deserializer<'de>,
16175 {
16176 const FIELDS: &[&str] = &[
16177 "source_id",
16178 "sourceId",
16179 "state_table",
16180 "stateTable",
16181 "row_id_index",
16182 "rowIdIndex",
16183 "columns",
16184 "with_properties",
16185 "withProperties",
16186 "info",
16187 "source_name",
16188 "sourceName",
16189 "rate_limit",
16190 "rateLimit",
16191 "secret_refs",
16192 "secretRefs",
16193 "refresh_mode",
16194 "refreshMode",
16195 "associated_table_id",
16196 "associatedTableId",
16197 ];
16198
16199 #[allow(clippy::enum_variant_names)]
16200 enum GeneratedField {
16201 SourceId,
16202 StateTable,
16203 RowIdIndex,
16204 Columns,
16205 WithProperties,
16206 Info,
16207 SourceName,
16208 RateLimit,
16209 SecretRefs,
16210 RefreshMode,
16211 AssociatedTableId,
16212 }
16213 impl<'de> serde::Deserialize<'de> for GeneratedField {
16214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16215 where
16216 D: serde::Deserializer<'de>,
16217 {
16218 struct GeneratedVisitor;
16219
16220 impl serde::de::Visitor<'_> for GeneratedVisitor {
16221 type Value = GeneratedField;
16222
16223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16224 write!(formatter, "expected one of: {:?}", &FIELDS)
16225 }
16226
16227 #[allow(unused_variables)]
16228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16229 where
16230 E: serde::de::Error,
16231 {
16232 match value {
16233 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
16234 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
16235 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
16236 "columns" => Ok(GeneratedField::Columns),
16237 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
16238 "info" => Ok(GeneratedField::Info),
16239 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
16240 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16241 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
16242 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
16243 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
16244 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16245 }
16246 }
16247 }
16248 deserializer.deserialize_identifier(GeneratedVisitor)
16249 }
16250 }
16251 struct GeneratedVisitor;
16252 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16253 type Value = StreamFsFetch;
16254
16255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16256 formatter.write_str("struct stream_plan.StreamFsFetch")
16257 }
16258
16259 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
16260 where
16261 V: serde::de::MapAccess<'de>,
16262 {
16263 let mut source_id__ = None;
16264 let mut state_table__ = None;
16265 let mut row_id_index__ = None;
16266 let mut columns__ = None;
16267 let mut with_properties__ = None;
16268 let mut info__ = None;
16269 let mut source_name__ = None;
16270 let mut rate_limit__ = None;
16271 let mut secret_refs__ = None;
16272 let mut refresh_mode__ = None;
16273 let mut associated_table_id__ = None;
16274 while let Some(k) = map_.next_key()? {
16275 match k {
16276 GeneratedField::SourceId => {
16277 if source_id__.is_some() {
16278 return Err(serde::de::Error::duplicate_field("sourceId"));
16279 }
16280 source_id__ =
16281 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16282 ;
16283 }
16284 GeneratedField::StateTable => {
16285 if state_table__.is_some() {
16286 return Err(serde::de::Error::duplicate_field("stateTable"));
16287 }
16288 state_table__ = map_.next_value()?;
16289 }
16290 GeneratedField::RowIdIndex => {
16291 if row_id_index__.is_some() {
16292 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
16293 }
16294 row_id_index__ =
16295 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16296 ;
16297 }
16298 GeneratedField::Columns => {
16299 if columns__.is_some() {
16300 return Err(serde::de::Error::duplicate_field("columns"));
16301 }
16302 columns__ = Some(map_.next_value()?);
16303 }
16304 GeneratedField::WithProperties => {
16305 if with_properties__.is_some() {
16306 return Err(serde::de::Error::duplicate_field("withProperties"));
16307 }
16308 with_properties__ = Some(
16309 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16310 );
16311 }
16312 GeneratedField::Info => {
16313 if info__.is_some() {
16314 return Err(serde::de::Error::duplicate_field("info"));
16315 }
16316 info__ = map_.next_value()?;
16317 }
16318 GeneratedField::SourceName => {
16319 if source_name__.is_some() {
16320 return Err(serde::de::Error::duplicate_field("sourceName"));
16321 }
16322 source_name__ = Some(map_.next_value()?);
16323 }
16324 GeneratedField::RateLimit => {
16325 if rate_limit__.is_some() {
16326 return Err(serde::de::Error::duplicate_field("rateLimit"));
16327 }
16328 rate_limit__ =
16329 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16330 ;
16331 }
16332 GeneratedField::SecretRefs => {
16333 if secret_refs__.is_some() {
16334 return Err(serde::de::Error::duplicate_field("secretRefs"));
16335 }
16336 secret_refs__ = Some(
16337 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16338 );
16339 }
16340 GeneratedField::RefreshMode => {
16341 if refresh_mode__.is_some() {
16342 return Err(serde::de::Error::duplicate_field("refreshMode"));
16343 }
16344 refresh_mode__ = map_.next_value()?;
16345 }
16346 GeneratedField::AssociatedTableId => {
16347 if associated_table_id__.is_some() {
16348 return Err(serde::de::Error::duplicate_field("associatedTableId"));
16349 }
16350 associated_table_id__ =
16351 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16352 ;
16353 }
16354 }
16355 }
16356 Ok(StreamFsFetch {
16357 source_id: source_id__.unwrap_or_default(),
16358 state_table: state_table__,
16359 row_id_index: row_id_index__,
16360 columns: columns__.unwrap_or_default(),
16361 with_properties: with_properties__.unwrap_or_default(),
16362 info: info__,
16363 source_name: source_name__.unwrap_or_default(),
16364 rate_limit: rate_limit__,
16365 secret_refs: secret_refs__.unwrap_or_default(),
16366 refresh_mode: refresh_mode__,
16367 associated_table_id: associated_table_id__,
16368 })
16369 }
16370 }
16371 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
16372 }
16373}
16374impl serde::Serialize for StreamFsFetchNode {
16375 #[allow(deprecated)]
16376 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16377 where
16378 S: serde::Serializer,
16379 {
16380 use serde::ser::SerializeStruct;
16381 let mut len = 0;
16382 if self.node_inner.is_some() {
16383 len += 1;
16384 }
16385 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
16386 if let Some(v) = self.node_inner.as_ref() {
16387 struct_ser.serialize_field("nodeInner", v)?;
16388 }
16389 struct_ser.end()
16390 }
16391}
16392impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
16393 #[allow(deprecated)]
16394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16395 where
16396 D: serde::Deserializer<'de>,
16397 {
16398 const FIELDS: &[&str] = &[
16399 "node_inner",
16400 "nodeInner",
16401 ];
16402
16403 #[allow(clippy::enum_variant_names)]
16404 enum GeneratedField {
16405 NodeInner,
16406 }
16407 impl<'de> serde::Deserialize<'de> for GeneratedField {
16408 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16409 where
16410 D: serde::Deserializer<'de>,
16411 {
16412 struct GeneratedVisitor;
16413
16414 impl serde::de::Visitor<'_> for GeneratedVisitor {
16415 type Value = GeneratedField;
16416
16417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16418 write!(formatter, "expected one of: {:?}", &FIELDS)
16419 }
16420
16421 #[allow(unused_variables)]
16422 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16423 where
16424 E: serde::de::Error,
16425 {
16426 match value {
16427 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
16428 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16429 }
16430 }
16431 }
16432 deserializer.deserialize_identifier(GeneratedVisitor)
16433 }
16434 }
16435 struct GeneratedVisitor;
16436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16437 type Value = StreamFsFetchNode;
16438
16439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16440 formatter.write_str("struct stream_plan.StreamFsFetchNode")
16441 }
16442
16443 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
16444 where
16445 V: serde::de::MapAccess<'de>,
16446 {
16447 let mut node_inner__ = None;
16448 while let Some(k) = map_.next_key()? {
16449 match k {
16450 GeneratedField::NodeInner => {
16451 if node_inner__.is_some() {
16452 return Err(serde::de::Error::duplicate_field("nodeInner"));
16453 }
16454 node_inner__ = map_.next_value()?;
16455 }
16456 }
16457 }
16458 Ok(StreamFsFetchNode {
16459 node_inner: node_inner__,
16460 })
16461 }
16462 }
16463 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
16464 }
16465}
16466impl serde::Serialize for StreamMessage {
16467 #[allow(deprecated)]
16468 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16469 where
16470 S: serde::Serializer,
16471 {
16472 use serde::ser::SerializeStruct;
16473 let mut len = 0;
16474 if self.stream_message.is_some() {
16475 len += 1;
16476 }
16477 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
16478 if let Some(v) = self.stream_message.as_ref() {
16479 match v {
16480 stream_message::StreamMessage::StreamChunk(v) => {
16481 struct_ser.serialize_field("streamChunk", v)?;
16482 }
16483 stream_message::StreamMessage::Barrier(v) => {
16484 struct_ser.serialize_field("barrier", v)?;
16485 }
16486 stream_message::StreamMessage::Watermark(v) => {
16487 struct_ser.serialize_field("watermark", v)?;
16488 }
16489 }
16490 }
16491 struct_ser.end()
16492 }
16493}
16494impl<'de> serde::Deserialize<'de> for StreamMessage {
16495 #[allow(deprecated)]
16496 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16497 where
16498 D: serde::Deserializer<'de>,
16499 {
16500 const FIELDS: &[&str] = &[
16501 "stream_chunk",
16502 "streamChunk",
16503 "barrier",
16504 "watermark",
16505 ];
16506
16507 #[allow(clippy::enum_variant_names)]
16508 enum GeneratedField {
16509 StreamChunk,
16510 Barrier,
16511 Watermark,
16512 }
16513 impl<'de> serde::Deserialize<'de> for GeneratedField {
16514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16515 where
16516 D: serde::Deserializer<'de>,
16517 {
16518 struct GeneratedVisitor;
16519
16520 impl serde::de::Visitor<'_> for GeneratedVisitor {
16521 type Value = GeneratedField;
16522
16523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16524 write!(formatter, "expected one of: {:?}", &FIELDS)
16525 }
16526
16527 #[allow(unused_variables)]
16528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16529 where
16530 E: serde::de::Error,
16531 {
16532 match value {
16533 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
16534 "barrier" => Ok(GeneratedField::Barrier),
16535 "watermark" => Ok(GeneratedField::Watermark),
16536 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16537 }
16538 }
16539 }
16540 deserializer.deserialize_identifier(GeneratedVisitor)
16541 }
16542 }
16543 struct GeneratedVisitor;
16544 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16545 type Value = StreamMessage;
16546
16547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16548 formatter.write_str("struct stream_plan.StreamMessage")
16549 }
16550
16551 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
16552 where
16553 V: serde::de::MapAccess<'de>,
16554 {
16555 let mut stream_message__ = None;
16556 while let Some(k) = map_.next_key()? {
16557 match k {
16558 GeneratedField::StreamChunk => {
16559 if stream_message__.is_some() {
16560 return Err(serde::de::Error::duplicate_field("streamChunk"));
16561 }
16562 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
16563;
16564 }
16565 GeneratedField::Barrier => {
16566 if stream_message__.is_some() {
16567 return Err(serde::de::Error::duplicate_field("barrier"));
16568 }
16569 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
16570;
16571 }
16572 GeneratedField::Watermark => {
16573 if stream_message__.is_some() {
16574 return Err(serde::de::Error::duplicate_field("watermark"));
16575 }
16576 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
16577;
16578 }
16579 }
16580 }
16581 Ok(StreamMessage {
16582 stream_message: stream_message__,
16583 })
16584 }
16585 }
16586 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
16587 }
16588}
16589impl serde::Serialize for StreamMessageBatch {
16590 #[allow(deprecated)]
16591 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16592 where
16593 S: serde::Serializer,
16594 {
16595 use serde::ser::SerializeStruct;
16596 let mut len = 0;
16597 if self.stream_message_batch.is_some() {
16598 len += 1;
16599 }
16600 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
16601 if let Some(v) = self.stream_message_batch.as_ref() {
16602 match v {
16603 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
16604 struct_ser.serialize_field("streamChunk", v)?;
16605 }
16606 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
16607 struct_ser.serialize_field("barrierBatch", v)?;
16608 }
16609 stream_message_batch::StreamMessageBatch::Watermark(v) => {
16610 struct_ser.serialize_field("watermark", v)?;
16611 }
16612 }
16613 }
16614 struct_ser.end()
16615 }
16616}
16617impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
16618 #[allow(deprecated)]
16619 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16620 where
16621 D: serde::Deserializer<'de>,
16622 {
16623 const FIELDS: &[&str] = &[
16624 "stream_chunk",
16625 "streamChunk",
16626 "barrier_batch",
16627 "barrierBatch",
16628 "watermark",
16629 ];
16630
16631 #[allow(clippy::enum_variant_names)]
16632 enum GeneratedField {
16633 StreamChunk,
16634 BarrierBatch,
16635 Watermark,
16636 }
16637 impl<'de> serde::Deserialize<'de> for GeneratedField {
16638 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16639 where
16640 D: serde::Deserializer<'de>,
16641 {
16642 struct GeneratedVisitor;
16643
16644 impl serde::de::Visitor<'_> for GeneratedVisitor {
16645 type Value = GeneratedField;
16646
16647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16648 write!(formatter, "expected one of: {:?}", &FIELDS)
16649 }
16650
16651 #[allow(unused_variables)]
16652 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16653 where
16654 E: serde::de::Error,
16655 {
16656 match value {
16657 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
16658 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
16659 "watermark" => Ok(GeneratedField::Watermark),
16660 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16661 }
16662 }
16663 }
16664 deserializer.deserialize_identifier(GeneratedVisitor)
16665 }
16666 }
16667 struct GeneratedVisitor;
16668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16669 type Value = StreamMessageBatch;
16670
16671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16672 formatter.write_str("struct stream_plan.StreamMessageBatch")
16673 }
16674
16675 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
16676 where
16677 V: serde::de::MapAccess<'de>,
16678 {
16679 let mut stream_message_batch__ = None;
16680 while let Some(k) = map_.next_key()? {
16681 match k {
16682 GeneratedField::StreamChunk => {
16683 if stream_message_batch__.is_some() {
16684 return Err(serde::de::Error::duplicate_field("streamChunk"));
16685 }
16686 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
16687;
16688 }
16689 GeneratedField::BarrierBatch => {
16690 if stream_message_batch__.is_some() {
16691 return Err(serde::de::Error::duplicate_field("barrierBatch"));
16692 }
16693 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
16694;
16695 }
16696 GeneratedField::Watermark => {
16697 if stream_message_batch__.is_some() {
16698 return Err(serde::de::Error::duplicate_field("watermark"));
16699 }
16700 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
16701;
16702 }
16703 }
16704 }
16705 Ok(StreamMessageBatch {
16706 stream_message_batch: stream_message_batch__,
16707 })
16708 }
16709 }
16710 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
16711 }
16712}
16713impl serde::Serialize for stream_message_batch::BarrierBatch {
16714 #[allow(deprecated)]
16715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16716 where
16717 S: serde::Serializer,
16718 {
16719 use serde::ser::SerializeStruct;
16720 let mut len = 0;
16721 if !self.barriers.is_empty() {
16722 len += 1;
16723 }
16724 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
16725 if !self.barriers.is_empty() {
16726 struct_ser.serialize_field("barriers", &self.barriers)?;
16727 }
16728 struct_ser.end()
16729 }
16730}
16731impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
16732 #[allow(deprecated)]
16733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16734 where
16735 D: serde::Deserializer<'de>,
16736 {
16737 const FIELDS: &[&str] = &[
16738 "barriers",
16739 ];
16740
16741 #[allow(clippy::enum_variant_names)]
16742 enum GeneratedField {
16743 Barriers,
16744 }
16745 impl<'de> serde::Deserialize<'de> for GeneratedField {
16746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16747 where
16748 D: serde::Deserializer<'de>,
16749 {
16750 struct GeneratedVisitor;
16751
16752 impl serde::de::Visitor<'_> for GeneratedVisitor {
16753 type Value = GeneratedField;
16754
16755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16756 write!(formatter, "expected one of: {:?}", &FIELDS)
16757 }
16758
16759 #[allow(unused_variables)]
16760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16761 where
16762 E: serde::de::Error,
16763 {
16764 match value {
16765 "barriers" => Ok(GeneratedField::Barriers),
16766 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16767 }
16768 }
16769 }
16770 deserializer.deserialize_identifier(GeneratedVisitor)
16771 }
16772 }
16773 struct GeneratedVisitor;
16774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16775 type Value = stream_message_batch::BarrierBatch;
16776
16777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16778 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
16779 }
16780
16781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
16782 where
16783 V: serde::de::MapAccess<'de>,
16784 {
16785 let mut barriers__ = None;
16786 while let Some(k) = map_.next_key()? {
16787 match k {
16788 GeneratedField::Barriers => {
16789 if barriers__.is_some() {
16790 return Err(serde::de::Error::duplicate_field("barriers"));
16791 }
16792 barriers__ = Some(map_.next_value()?);
16793 }
16794 }
16795 }
16796 Ok(stream_message_batch::BarrierBatch {
16797 barriers: barriers__.unwrap_or_default(),
16798 })
16799 }
16800 }
16801 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
16802 }
16803}
16804impl serde::Serialize for StreamNode {
16805 #[allow(deprecated)]
16806 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16807 where
16808 S: serde::Serializer,
16809 {
16810 use serde::ser::SerializeStruct;
16811 let mut len = 0;
16812 if self.operator_id != 0 {
16813 len += 1;
16814 }
16815 if !self.input.is_empty() {
16816 len += 1;
16817 }
16818 if !self.stream_key.is_empty() {
16819 len += 1;
16820 }
16821 if self.stream_kind != 0 {
16822 len += 1;
16823 }
16824 if !self.identity.is_empty() {
16825 len += 1;
16826 }
16827 if !self.fields.is_empty() {
16828 len += 1;
16829 }
16830 if self.node_body.is_some() {
16831 len += 1;
16832 }
16833 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
16834 if self.operator_id != 0 {
16835 #[allow(clippy::needless_borrow)]
16836 #[allow(clippy::needless_borrows_for_generic_args)]
16837 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
16838 }
16839 if !self.input.is_empty() {
16840 struct_ser.serialize_field("input", &self.input)?;
16841 }
16842 if !self.stream_key.is_empty() {
16843 struct_ser.serialize_field("streamKey", &self.stream_key)?;
16844 }
16845 if self.stream_kind != 0 {
16846 let v = stream_node::StreamKind::try_from(self.stream_kind)
16847 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
16848 struct_ser.serialize_field("streamKind", &v)?;
16849 }
16850 if !self.identity.is_empty() {
16851 struct_ser.serialize_field("identity", &self.identity)?;
16852 }
16853 if !self.fields.is_empty() {
16854 struct_ser.serialize_field("fields", &self.fields)?;
16855 }
16856 if let Some(v) = self.node_body.as_ref() {
16857 match v {
16858 stream_node::NodeBody::Source(v) => {
16859 struct_ser.serialize_field("source", v)?;
16860 }
16861 stream_node::NodeBody::Project(v) => {
16862 struct_ser.serialize_field("project", v)?;
16863 }
16864 stream_node::NodeBody::Filter(v) => {
16865 struct_ser.serialize_field("filter", v)?;
16866 }
16867 stream_node::NodeBody::Materialize(v) => {
16868 struct_ser.serialize_field("materialize", v)?;
16869 }
16870 stream_node::NodeBody::StatelessSimpleAgg(v) => {
16871 struct_ser.serialize_field("statelessSimpleAgg", v)?;
16872 }
16873 stream_node::NodeBody::SimpleAgg(v) => {
16874 struct_ser.serialize_field("simpleAgg", v)?;
16875 }
16876 stream_node::NodeBody::HashAgg(v) => {
16877 struct_ser.serialize_field("hashAgg", v)?;
16878 }
16879 stream_node::NodeBody::AppendOnlyTopN(v) => {
16880 struct_ser.serialize_field("appendOnlyTopN", v)?;
16881 }
16882 stream_node::NodeBody::HashJoin(v) => {
16883 struct_ser.serialize_field("hashJoin", v)?;
16884 }
16885 stream_node::NodeBody::TopN(v) => {
16886 struct_ser.serialize_field("topN", v)?;
16887 }
16888 stream_node::NodeBody::HopWindow(v) => {
16889 struct_ser.serialize_field("hopWindow", v)?;
16890 }
16891 stream_node::NodeBody::Merge(v) => {
16892 struct_ser.serialize_field("merge", v)?;
16893 }
16894 stream_node::NodeBody::Exchange(v) => {
16895 struct_ser.serialize_field("exchange", v)?;
16896 }
16897 stream_node::NodeBody::StreamScan(v) => {
16898 struct_ser.serialize_field("streamScan", v)?;
16899 }
16900 stream_node::NodeBody::BatchPlan(v) => {
16901 struct_ser.serialize_field("batchPlan", v)?;
16902 }
16903 stream_node::NodeBody::Lookup(v) => {
16904 struct_ser.serialize_field("lookup", v)?;
16905 }
16906 stream_node::NodeBody::Arrange(v) => {
16907 struct_ser.serialize_field("arrange", v)?;
16908 }
16909 stream_node::NodeBody::LookupUnion(v) => {
16910 struct_ser.serialize_field("lookupUnion", v)?;
16911 }
16912 stream_node::NodeBody::Union(v) => {
16913 struct_ser.serialize_field("union", v)?;
16914 }
16915 stream_node::NodeBody::DeltaIndexJoin(v) => {
16916 struct_ser.serialize_field("deltaIndexJoin", v)?;
16917 }
16918 stream_node::NodeBody::Sink(v) => {
16919 struct_ser.serialize_field("sink", v)?;
16920 }
16921 stream_node::NodeBody::Expand(v) => {
16922 struct_ser.serialize_field("expand", v)?;
16923 }
16924 stream_node::NodeBody::DynamicFilter(v) => {
16925 struct_ser.serialize_field("dynamicFilter", v)?;
16926 }
16927 stream_node::NodeBody::ProjectSet(v) => {
16928 struct_ser.serialize_field("projectSet", v)?;
16929 }
16930 stream_node::NodeBody::GroupTopN(v) => {
16931 struct_ser.serialize_field("groupTopN", v)?;
16932 }
16933 stream_node::NodeBody::Sort(v) => {
16934 struct_ser.serialize_field("sort", v)?;
16935 }
16936 stream_node::NodeBody::WatermarkFilter(v) => {
16937 struct_ser.serialize_field("watermarkFilter", v)?;
16938 }
16939 stream_node::NodeBody::Dml(v) => {
16940 struct_ser.serialize_field("dml", v)?;
16941 }
16942 stream_node::NodeBody::RowIdGen(v) => {
16943 struct_ser.serialize_field("rowIdGen", v)?;
16944 }
16945 stream_node::NodeBody::Now(v) => {
16946 struct_ser.serialize_field("now", v)?;
16947 }
16948 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
16949 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
16950 }
16951 stream_node::NodeBody::TemporalJoin(v) => {
16952 struct_ser.serialize_field("temporalJoin", v)?;
16953 }
16954 stream_node::NodeBody::BarrierRecv(v) => {
16955 struct_ser.serialize_field("barrierRecv", v)?;
16956 }
16957 stream_node::NodeBody::Values(v) => {
16958 struct_ser.serialize_field("values", v)?;
16959 }
16960 stream_node::NodeBody::AppendOnlyDedup(v) => {
16961 struct_ser.serialize_field("appendOnlyDedup", v)?;
16962 }
16963 stream_node::NodeBody::NoOp(v) => {
16964 struct_ser.serialize_field("noOp", v)?;
16965 }
16966 stream_node::NodeBody::EowcOverWindow(v) => {
16967 struct_ser.serialize_field("eowcOverWindow", v)?;
16968 }
16969 stream_node::NodeBody::OverWindow(v) => {
16970 struct_ser.serialize_field("overWindow", v)?;
16971 }
16972 stream_node::NodeBody::StreamFsFetch(v) => {
16973 struct_ser.serialize_field("streamFsFetch", v)?;
16974 }
16975 stream_node::NodeBody::StreamCdcScan(v) => {
16976 struct_ser.serialize_field("streamCdcScan", v)?;
16977 }
16978 stream_node::NodeBody::CdcFilter(v) => {
16979 struct_ser.serialize_field("cdcFilter", v)?;
16980 }
16981 stream_node::NodeBody::SourceBackfill(v) => {
16982 struct_ser.serialize_field("sourceBackfill", v)?;
16983 }
16984 stream_node::NodeBody::Changelog(v) => {
16985 struct_ser.serialize_field("changelog", v)?;
16986 }
16987 stream_node::NodeBody::LocalApproxPercentile(v) => {
16988 struct_ser.serialize_field("localApproxPercentile", v)?;
16989 }
16990 stream_node::NodeBody::GlobalApproxPercentile(v) => {
16991 struct_ser.serialize_field("globalApproxPercentile", v)?;
16992 }
16993 stream_node::NodeBody::RowMerge(v) => {
16994 struct_ser.serialize_field("rowMerge", v)?;
16995 }
16996 stream_node::NodeBody::AsOfJoin(v) => {
16997 struct_ser.serialize_field("asOfJoin", v)?;
16998 }
16999 stream_node::NodeBody::SyncLogStore(v) => {
17000 struct_ser.serialize_field("syncLogStore", v)?;
17001 }
17002 stream_node::NodeBody::MaterializedExprs(v) => {
17003 struct_ser.serialize_field("materializedExprs", v)?;
17004 }
17005 stream_node::NodeBody::VectorIndexWrite(v) => {
17006 struct_ser.serialize_field("vectorIndexWrite", v)?;
17007 }
17008 stream_node::NodeBody::UpstreamSinkUnion(v) => {
17009 struct_ser.serialize_field("upstreamSinkUnion", v)?;
17010 }
17011 stream_node::NodeBody::LocalityProvider(v) => {
17012 struct_ser.serialize_field("localityProvider", v)?;
17013 }
17014 stream_node::NodeBody::EowcGapFill(v) => {
17015 struct_ser.serialize_field("eowcGapFill", v)?;
17016 }
17017 stream_node::NodeBody::GapFill(v) => {
17018 struct_ser.serialize_field("gapFill", v)?;
17019 }
17020 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
17021 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
17022 }
17023 stream_node::NodeBody::IcebergWithPkIndexWriter(v) => {
17024 struct_ser.serialize_field("icebergWithPkIndexWriter", v)?;
17025 }
17026 stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger(v) => {
17027 struct_ser.serialize_field("icebergWithPkIndexPositionDeleteMerger", v)?;
17028 }
17029 stream_node::NodeBody::MatchRecognize(v) => {
17030 struct_ser.serialize_field("matchRecognize", v)?;
17031 }
17032 stream_node::NodeBody::CompactionResolver(v) => {
17033 struct_ser.serialize_field("compactionResolver", v)?;
17034 }
17035 }
17036 }
17037 struct_ser.end()
17038 }
17039}
17040impl<'de> serde::Deserialize<'de> for StreamNode {
17041 #[allow(deprecated)]
17042 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17043 where
17044 D: serde::Deserializer<'de>,
17045 {
17046 const FIELDS: &[&str] = &[
17047 "operator_id",
17048 "operatorId",
17049 "input",
17050 "stream_key",
17051 "streamKey",
17052 "stream_kind",
17053 "streamKind",
17054 "identity",
17055 "fields",
17056 "source",
17057 "project",
17058 "filter",
17059 "materialize",
17060 "stateless_simple_agg",
17061 "statelessSimpleAgg",
17062 "simple_agg",
17063 "simpleAgg",
17064 "hash_agg",
17065 "hashAgg",
17066 "append_only_top_n",
17067 "appendOnlyTopN",
17068 "hash_join",
17069 "hashJoin",
17070 "top_n",
17071 "topN",
17072 "hop_window",
17073 "hopWindow",
17074 "merge",
17075 "exchange",
17076 "stream_scan",
17077 "streamScan",
17078 "batch_plan",
17079 "batchPlan",
17080 "lookup",
17081 "arrange",
17082 "lookup_union",
17083 "lookupUnion",
17084 "union",
17085 "delta_index_join",
17086 "deltaIndexJoin",
17087 "sink",
17088 "expand",
17089 "dynamic_filter",
17090 "dynamicFilter",
17091 "project_set",
17092 "projectSet",
17093 "group_top_n",
17094 "groupTopN",
17095 "sort",
17096 "watermark_filter",
17097 "watermarkFilter",
17098 "dml",
17099 "row_id_gen",
17100 "rowIdGen",
17101 "now",
17102 "append_only_group_top_n",
17103 "appendOnlyGroupTopN",
17104 "temporal_join",
17105 "temporalJoin",
17106 "barrier_recv",
17107 "barrierRecv",
17108 "values",
17109 "append_only_dedup",
17110 "appendOnlyDedup",
17111 "no_op",
17112 "noOp",
17113 "eowc_over_window",
17114 "eowcOverWindow",
17115 "over_window",
17116 "overWindow",
17117 "stream_fs_fetch",
17118 "streamFsFetch",
17119 "stream_cdc_scan",
17120 "streamCdcScan",
17121 "cdc_filter",
17122 "cdcFilter",
17123 "source_backfill",
17124 "sourceBackfill",
17125 "changelog",
17126 "local_approx_percentile",
17127 "localApproxPercentile",
17128 "global_approx_percentile",
17129 "globalApproxPercentile",
17130 "row_merge",
17131 "rowMerge",
17132 "as_of_join",
17133 "asOfJoin",
17134 "sync_log_store",
17135 "syncLogStore",
17136 "materialized_exprs",
17137 "materializedExprs",
17138 "vector_index_write",
17139 "vectorIndexWrite",
17140 "upstream_sink_union",
17141 "upstreamSinkUnion",
17142 "locality_provider",
17143 "localityProvider",
17144 "eowc_gap_fill",
17145 "eowcGapFill",
17146 "gap_fill",
17147 "gapFill",
17148 "vector_index_lookup_join",
17149 "vectorIndexLookupJoin",
17150 "iceberg_with_pk_index_writer",
17151 "icebergWithPkIndexWriter",
17152 "iceberg_with_pk_index_position_delete_merger",
17153 "icebergWithPkIndexPositionDeleteMerger",
17154 "match_recognize",
17155 "matchRecognize",
17156 "compaction_resolver",
17157 "compactionResolver",
17158 ];
17159
17160 #[allow(clippy::enum_variant_names)]
17161 enum GeneratedField {
17162 OperatorId,
17163 Input,
17164 StreamKey,
17165 StreamKind,
17166 Identity,
17167 Fields,
17168 Source,
17169 Project,
17170 Filter,
17171 Materialize,
17172 StatelessSimpleAgg,
17173 SimpleAgg,
17174 HashAgg,
17175 AppendOnlyTopN,
17176 HashJoin,
17177 TopN,
17178 HopWindow,
17179 Merge,
17180 Exchange,
17181 StreamScan,
17182 BatchPlan,
17183 Lookup,
17184 Arrange,
17185 LookupUnion,
17186 Union,
17187 DeltaIndexJoin,
17188 Sink,
17189 Expand,
17190 DynamicFilter,
17191 ProjectSet,
17192 GroupTopN,
17193 Sort,
17194 WatermarkFilter,
17195 Dml,
17196 RowIdGen,
17197 Now,
17198 AppendOnlyGroupTopN,
17199 TemporalJoin,
17200 BarrierRecv,
17201 Values,
17202 AppendOnlyDedup,
17203 NoOp,
17204 EowcOverWindow,
17205 OverWindow,
17206 StreamFsFetch,
17207 StreamCdcScan,
17208 CdcFilter,
17209 SourceBackfill,
17210 Changelog,
17211 LocalApproxPercentile,
17212 GlobalApproxPercentile,
17213 RowMerge,
17214 AsOfJoin,
17215 SyncLogStore,
17216 MaterializedExprs,
17217 VectorIndexWrite,
17218 UpstreamSinkUnion,
17219 LocalityProvider,
17220 EowcGapFill,
17221 GapFill,
17222 VectorIndexLookupJoin,
17223 IcebergWithPkIndexWriter,
17224 IcebergWithPkIndexPositionDeleteMerger,
17225 MatchRecognize,
17226 CompactionResolver,
17227 }
17228 impl<'de> serde::Deserialize<'de> for GeneratedField {
17229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17230 where
17231 D: serde::Deserializer<'de>,
17232 {
17233 struct GeneratedVisitor;
17234
17235 impl serde::de::Visitor<'_> for GeneratedVisitor {
17236 type Value = GeneratedField;
17237
17238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17239 write!(formatter, "expected one of: {:?}", &FIELDS)
17240 }
17241
17242 #[allow(unused_variables)]
17243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17244 where
17245 E: serde::de::Error,
17246 {
17247 match value {
17248 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
17249 "input" => Ok(GeneratedField::Input),
17250 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
17251 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
17252 "identity" => Ok(GeneratedField::Identity),
17253 "fields" => Ok(GeneratedField::Fields),
17254 "source" => Ok(GeneratedField::Source),
17255 "project" => Ok(GeneratedField::Project),
17256 "filter" => Ok(GeneratedField::Filter),
17257 "materialize" => Ok(GeneratedField::Materialize),
17258 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
17259 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
17260 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
17261 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
17262 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
17263 "topN" | "top_n" => Ok(GeneratedField::TopN),
17264 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
17265 "merge" => Ok(GeneratedField::Merge),
17266 "exchange" => Ok(GeneratedField::Exchange),
17267 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
17268 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
17269 "lookup" => Ok(GeneratedField::Lookup),
17270 "arrange" => Ok(GeneratedField::Arrange),
17271 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
17272 "union" => Ok(GeneratedField::Union),
17273 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
17274 "sink" => Ok(GeneratedField::Sink),
17275 "expand" => Ok(GeneratedField::Expand),
17276 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
17277 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
17278 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
17279 "sort" => Ok(GeneratedField::Sort),
17280 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
17281 "dml" => Ok(GeneratedField::Dml),
17282 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
17283 "now" => Ok(GeneratedField::Now),
17284 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
17285 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
17286 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
17287 "values" => Ok(GeneratedField::Values),
17288 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
17289 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
17290 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
17291 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
17292 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
17293 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
17294 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
17295 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
17296 "changelog" => Ok(GeneratedField::Changelog),
17297 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
17298 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
17299 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
17300 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
17301 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
17302 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
17303 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
17304 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
17305 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
17306 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
17307 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
17308 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
17309 "icebergWithPkIndexWriter" | "iceberg_with_pk_index_writer" => Ok(GeneratedField::IcebergWithPkIndexWriter),
17310 "icebergWithPkIndexPositionDeleteMerger" | "iceberg_with_pk_index_position_delete_merger" => Ok(GeneratedField::IcebergWithPkIndexPositionDeleteMerger),
17311 "matchRecognize" | "match_recognize" => Ok(GeneratedField::MatchRecognize),
17312 "compactionResolver" | "compaction_resolver" => Ok(GeneratedField::CompactionResolver),
17313 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17314 }
17315 }
17316 }
17317 deserializer.deserialize_identifier(GeneratedVisitor)
17318 }
17319 }
17320 struct GeneratedVisitor;
17321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17322 type Value = StreamNode;
17323
17324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17325 formatter.write_str("struct stream_plan.StreamNode")
17326 }
17327
17328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
17329 where
17330 V: serde::de::MapAccess<'de>,
17331 {
17332 let mut operator_id__ = None;
17333 let mut input__ = None;
17334 let mut stream_key__ = None;
17335 let mut stream_kind__ = None;
17336 let mut identity__ = None;
17337 let mut fields__ = None;
17338 let mut node_body__ = None;
17339 while let Some(k) = map_.next_key()? {
17340 match k {
17341 GeneratedField::OperatorId => {
17342 if operator_id__.is_some() {
17343 return Err(serde::de::Error::duplicate_field("operatorId"));
17344 }
17345 operator_id__ =
17346 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17347 ;
17348 }
17349 GeneratedField::Input => {
17350 if input__.is_some() {
17351 return Err(serde::de::Error::duplicate_field("input"));
17352 }
17353 input__ = Some(map_.next_value()?);
17354 }
17355 GeneratedField::StreamKey => {
17356 if stream_key__.is_some() {
17357 return Err(serde::de::Error::duplicate_field("streamKey"));
17358 }
17359 stream_key__ =
17360 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17361 .into_iter().map(|x| x.0).collect())
17362 ;
17363 }
17364 GeneratedField::StreamKind => {
17365 if stream_kind__.is_some() {
17366 return Err(serde::de::Error::duplicate_field("streamKind"));
17367 }
17368 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
17369 }
17370 GeneratedField::Identity => {
17371 if identity__.is_some() {
17372 return Err(serde::de::Error::duplicate_field("identity"));
17373 }
17374 identity__ = Some(map_.next_value()?);
17375 }
17376 GeneratedField::Fields => {
17377 if fields__.is_some() {
17378 return Err(serde::de::Error::duplicate_field("fields"));
17379 }
17380 fields__ = Some(map_.next_value()?);
17381 }
17382 GeneratedField::Source => {
17383 if node_body__.is_some() {
17384 return Err(serde::de::Error::duplicate_field("source"));
17385 }
17386 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
17387;
17388 }
17389 GeneratedField::Project => {
17390 if node_body__.is_some() {
17391 return Err(serde::de::Error::duplicate_field("project"));
17392 }
17393 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
17394;
17395 }
17396 GeneratedField::Filter => {
17397 if node_body__.is_some() {
17398 return Err(serde::de::Error::duplicate_field("filter"));
17399 }
17400 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
17401;
17402 }
17403 GeneratedField::Materialize => {
17404 if node_body__.is_some() {
17405 return Err(serde::de::Error::duplicate_field("materialize"));
17406 }
17407 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
17408;
17409 }
17410 GeneratedField::StatelessSimpleAgg => {
17411 if node_body__.is_some() {
17412 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
17413 }
17414 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
17415;
17416 }
17417 GeneratedField::SimpleAgg => {
17418 if node_body__.is_some() {
17419 return Err(serde::de::Error::duplicate_field("simpleAgg"));
17420 }
17421 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
17422;
17423 }
17424 GeneratedField::HashAgg => {
17425 if node_body__.is_some() {
17426 return Err(serde::de::Error::duplicate_field("hashAgg"));
17427 }
17428 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
17429;
17430 }
17431 GeneratedField::AppendOnlyTopN => {
17432 if node_body__.is_some() {
17433 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
17434 }
17435 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
17436;
17437 }
17438 GeneratedField::HashJoin => {
17439 if node_body__.is_some() {
17440 return Err(serde::de::Error::duplicate_field("hashJoin"));
17441 }
17442 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
17443;
17444 }
17445 GeneratedField::TopN => {
17446 if node_body__.is_some() {
17447 return Err(serde::de::Error::duplicate_field("topN"));
17448 }
17449 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
17450;
17451 }
17452 GeneratedField::HopWindow => {
17453 if node_body__.is_some() {
17454 return Err(serde::de::Error::duplicate_field("hopWindow"));
17455 }
17456 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
17457;
17458 }
17459 GeneratedField::Merge => {
17460 if node_body__.is_some() {
17461 return Err(serde::de::Error::duplicate_field("merge"));
17462 }
17463 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
17464;
17465 }
17466 GeneratedField::Exchange => {
17467 if node_body__.is_some() {
17468 return Err(serde::de::Error::duplicate_field("exchange"));
17469 }
17470 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
17471;
17472 }
17473 GeneratedField::StreamScan => {
17474 if node_body__.is_some() {
17475 return Err(serde::de::Error::duplicate_field("streamScan"));
17476 }
17477 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
17478;
17479 }
17480 GeneratedField::BatchPlan => {
17481 if node_body__.is_some() {
17482 return Err(serde::de::Error::duplicate_field("batchPlan"));
17483 }
17484 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
17485;
17486 }
17487 GeneratedField::Lookup => {
17488 if node_body__.is_some() {
17489 return Err(serde::de::Error::duplicate_field("lookup"));
17490 }
17491 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
17492;
17493 }
17494 GeneratedField::Arrange => {
17495 if node_body__.is_some() {
17496 return Err(serde::de::Error::duplicate_field("arrange"));
17497 }
17498 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
17499;
17500 }
17501 GeneratedField::LookupUnion => {
17502 if node_body__.is_some() {
17503 return Err(serde::de::Error::duplicate_field("lookupUnion"));
17504 }
17505 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
17506;
17507 }
17508 GeneratedField::Union => {
17509 if node_body__.is_some() {
17510 return Err(serde::de::Error::duplicate_field("union"));
17511 }
17512 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
17513;
17514 }
17515 GeneratedField::DeltaIndexJoin => {
17516 if node_body__.is_some() {
17517 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
17518 }
17519 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
17520;
17521 }
17522 GeneratedField::Sink => {
17523 if node_body__.is_some() {
17524 return Err(serde::de::Error::duplicate_field("sink"));
17525 }
17526 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
17527;
17528 }
17529 GeneratedField::Expand => {
17530 if node_body__.is_some() {
17531 return Err(serde::de::Error::duplicate_field("expand"));
17532 }
17533 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
17534;
17535 }
17536 GeneratedField::DynamicFilter => {
17537 if node_body__.is_some() {
17538 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
17539 }
17540 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
17541;
17542 }
17543 GeneratedField::ProjectSet => {
17544 if node_body__.is_some() {
17545 return Err(serde::de::Error::duplicate_field("projectSet"));
17546 }
17547 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
17548;
17549 }
17550 GeneratedField::GroupTopN => {
17551 if node_body__.is_some() {
17552 return Err(serde::de::Error::duplicate_field("groupTopN"));
17553 }
17554 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
17555;
17556 }
17557 GeneratedField::Sort => {
17558 if node_body__.is_some() {
17559 return Err(serde::de::Error::duplicate_field("sort"));
17560 }
17561 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
17562;
17563 }
17564 GeneratedField::WatermarkFilter => {
17565 if node_body__.is_some() {
17566 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
17567 }
17568 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
17569;
17570 }
17571 GeneratedField::Dml => {
17572 if node_body__.is_some() {
17573 return Err(serde::de::Error::duplicate_field("dml"));
17574 }
17575 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
17576;
17577 }
17578 GeneratedField::RowIdGen => {
17579 if node_body__.is_some() {
17580 return Err(serde::de::Error::duplicate_field("rowIdGen"));
17581 }
17582 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
17583;
17584 }
17585 GeneratedField::Now => {
17586 if node_body__.is_some() {
17587 return Err(serde::de::Error::duplicate_field("now"));
17588 }
17589 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
17590;
17591 }
17592 GeneratedField::AppendOnlyGroupTopN => {
17593 if node_body__.is_some() {
17594 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
17595 }
17596 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
17597;
17598 }
17599 GeneratedField::TemporalJoin => {
17600 if node_body__.is_some() {
17601 return Err(serde::de::Error::duplicate_field("temporalJoin"));
17602 }
17603 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
17604;
17605 }
17606 GeneratedField::BarrierRecv => {
17607 if node_body__.is_some() {
17608 return Err(serde::de::Error::duplicate_field("barrierRecv"));
17609 }
17610 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
17611;
17612 }
17613 GeneratedField::Values => {
17614 if node_body__.is_some() {
17615 return Err(serde::de::Error::duplicate_field("values"));
17616 }
17617 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
17618;
17619 }
17620 GeneratedField::AppendOnlyDedup => {
17621 if node_body__.is_some() {
17622 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
17623 }
17624 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
17625;
17626 }
17627 GeneratedField::NoOp => {
17628 if node_body__.is_some() {
17629 return Err(serde::de::Error::duplicate_field("noOp"));
17630 }
17631 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
17632;
17633 }
17634 GeneratedField::EowcOverWindow => {
17635 if node_body__.is_some() {
17636 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
17637 }
17638 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
17639;
17640 }
17641 GeneratedField::OverWindow => {
17642 if node_body__.is_some() {
17643 return Err(serde::de::Error::duplicate_field("overWindow"));
17644 }
17645 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
17646;
17647 }
17648 GeneratedField::StreamFsFetch => {
17649 if node_body__.is_some() {
17650 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
17651 }
17652 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
17653;
17654 }
17655 GeneratedField::StreamCdcScan => {
17656 if node_body__.is_some() {
17657 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
17658 }
17659 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
17660;
17661 }
17662 GeneratedField::CdcFilter => {
17663 if node_body__.is_some() {
17664 return Err(serde::de::Error::duplicate_field("cdcFilter"));
17665 }
17666 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
17667;
17668 }
17669 GeneratedField::SourceBackfill => {
17670 if node_body__.is_some() {
17671 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
17672 }
17673 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
17674;
17675 }
17676 GeneratedField::Changelog => {
17677 if node_body__.is_some() {
17678 return Err(serde::de::Error::duplicate_field("changelog"));
17679 }
17680 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
17681;
17682 }
17683 GeneratedField::LocalApproxPercentile => {
17684 if node_body__.is_some() {
17685 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
17686 }
17687 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
17688;
17689 }
17690 GeneratedField::GlobalApproxPercentile => {
17691 if node_body__.is_some() {
17692 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
17693 }
17694 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
17695;
17696 }
17697 GeneratedField::RowMerge => {
17698 if node_body__.is_some() {
17699 return Err(serde::de::Error::duplicate_field("rowMerge"));
17700 }
17701 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
17702;
17703 }
17704 GeneratedField::AsOfJoin => {
17705 if node_body__.is_some() {
17706 return Err(serde::de::Error::duplicate_field("asOfJoin"));
17707 }
17708 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
17709;
17710 }
17711 GeneratedField::SyncLogStore => {
17712 if node_body__.is_some() {
17713 return Err(serde::de::Error::duplicate_field("syncLogStore"));
17714 }
17715 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
17716;
17717 }
17718 GeneratedField::MaterializedExprs => {
17719 if node_body__.is_some() {
17720 return Err(serde::de::Error::duplicate_field("materializedExprs"));
17721 }
17722 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
17723;
17724 }
17725 GeneratedField::VectorIndexWrite => {
17726 if node_body__.is_some() {
17727 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
17728 }
17729 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
17730;
17731 }
17732 GeneratedField::UpstreamSinkUnion => {
17733 if node_body__.is_some() {
17734 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
17735 }
17736 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
17737;
17738 }
17739 GeneratedField::LocalityProvider => {
17740 if node_body__.is_some() {
17741 return Err(serde::de::Error::duplicate_field("localityProvider"));
17742 }
17743 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
17744;
17745 }
17746 GeneratedField::EowcGapFill => {
17747 if node_body__.is_some() {
17748 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
17749 }
17750 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
17751;
17752 }
17753 GeneratedField::GapFill => {
17754 if node_body__.is_some() {
17755 return Err(serde::de::Error::duplicate_field("gapFill"));
17756 }
17757 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
17758;
17759 }
17760 GeneratedField::VectorIndexLookupJoin => {
17761 if node_body__.is_some() {
17762 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
17763 }
17764 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
17765;
17766 }
17767 GeneratedField::IcebergWithPkIndexWriter => {
17768 if node_body__.is_some() {
17769 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexWriter"));
17770 }
17771 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexWriter)
17772;
17773 }
17774 GeneratedField::IcebergWithPkIndexPositionDeleteMerger => {
17775 if node_body__.is_some() {
17776 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexPositionDeleteMerger"));
17777 }
17778 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger)
17779;
17780 }
17781 GeneratedField::MatchRecognize => {
17782 if node_body__.is_some() {
17783 return Err(serde::de::Error::duplicate_field("matchRecognize"));
17784 }
17785 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MatchRecognize)
17786;
17787 }
17788 GeneratedField::CompactionResolver => {
17789 if node_body__.is_some() {
17790 return Err(serde::de::Error::duplicate_field("compactionResolver"));
17791 }
17792 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CompactionResolver)
17793;
17794 }
17795 }
17796 }
17797 Ok(StreamNode {
17798 operator_id: operator_id__.unwrap_or_default(),
17799 input: input__.unwrap_or_default(),
17800 stream_key: stream_key__.unwrap_or_default(),
17801 stream_kind: stream_kind__.unwrap_or_default(),
17802 identity: identity__.unwrap_or_default(),
17803 fields: fields__.unwrap_or_default(),
17804 node_body: node_body__,
17805 })
17806 }
17807 }
17808 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
17809 }
17810}
17811impl serde::Serialize for stream_node::StreamKind {
17812 #[allow(deprecated)]
17813 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17814 where
17815 S: serde::Serializer,
17816 {
17817 let variant = match self {
17818 Self::Retract => "STREAM_KIND_RETRACT",
17819 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
17820 Self::Upsert => "STREAM_KIND_UPSERT",
17821 };
17822 serializer.serialize_str(variant)
17823 }
17824}
17825impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
17826 #[allow(deprecated)]
17827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17828 where
17829 D: serde::Deserializer<'de>,
17830 {
17831 const FIELDS: &[&str] = &[
17832 "STREAM_KIND_RETRACT",
17833 "STREAM_KIND_APPEND_ONLY",
17834 "STREAM_KIND_UPSERT",
17835 ];
17836
17837 struct GeneratedVisitor;
17838
17839 impl serde::de::Visitor<'_> for GeneratedVisitor {
17840 type Value = stream_node::StreamKind;
17841
17842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17843 write!(formatter, "expected one of: {:?}", &FIELDS)
17844 }
17845
17846 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17847 where
17848 E: serde::de::Error,
17849 {
17850 i32::try_from(v)
17851 .ok()
17852 .and_then(|x| x.try_into().ok())
17853 .ok_or_else(|| {
17854 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17855 })
17856 }
17857
17858 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17859 where
17860 E: serde::de::Error,
17861 {
17862 i32::try_from(v)
17863 .ok()
17864 .and_then(|x| x.try_into().ok())
17865 .ok_or_else(|| {
17866 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17867 })
17868 }
17869
17870 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17871 where
17872 E: serde::de::Error,
17873 {
17874 match value {
17875 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
17876 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
17877 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
17878 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17879 }
17880 }
17881 }
17882 deserializer.deserialize_any(GeneratedVisitor)
17883 }
17884}
17885impl serde::Serialize for StreamScanNode {
17886 #[allow(deprecated)]
17887 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17888 where
17889 S: serde::Serializer,
17890 {
17891 use serde::ser::SerializeStruct;
17892 let mut len = 0;
17893 if self.table_id != 0 {
17894 len += 1;
17895 }
17896 if !self.upstream_column_ids.is_empty() {
17897 len += 1;
17898 }
17899 if !self.output_indices.is_empty() {
17900 len += 1;
17901 }
17902 if self.stream_scan_type != 0 {
17903 len += 1;
17904 }
17905 if self.state_table.is_some() {
17906 len += 1;
17907 }
17908 if self.table_desc.is_some() {
17909 len += 1;
17910 }
17911 if self.rate_limit.is_some() {
17912 len += 1;
17913 }
17914 if self.snapshot_read_barrier_interval != 0 {
17915 len += 1;
17916 }
17917 if self.arrangement_table.is_some() {
17918 len += 1;
17919 }
17920 if self.snapshot_backfill_epoch.is_some() {
17921 len += 1;
17922 }
17923 if self.pk_scan_range.is_some() {
17924 len += 1;
17925 }
17926 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
17927 if self.table_id != 0 {
17928 struct_ser.serialize_field("tableId", &self.table_id)?;
17929 }
17930 if !self.upstream_column_ids.is_empty() {
17931 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
17932 }
17933 if !self.output_indices.is_empty() {
17934 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
17935 }
17936 if self.stream_scan_type != 0 {
17937 let v = StreamScanType::try_from(self.stream_scan_type)
17938 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
17939 struct_ser.serialize_field("streamScanType", &v)?;
17940 }
17941 if let Some(v) = self.state_table.as_ref() {
17942 struct_ser.serialize_field("stateTable", v)?;
17943 }
17944 if let Some(v) = self.table_desc.as_ref() {
17945 struct_ser.serialize_field("tableDesc", v)?;
17946 }
17947 if let Some(v) = self.rate_limit.as_ref() {
17948 struct_ser.serialize_field("rateLimit", v)?;
17949 }
17950 if self.snapshot_read_barrier_interval != 0 {
17951 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
17952 }
17953 if let Some(v) = self.arrangement_table.as_ref() {
17954 struct_ser.serialize_field("arrangementTable", v)?;
17955 }
17956 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
17957 #[allow(clippy::needless_borrow)]
17958 #[allow(clippy::needless_borrows_for_generic_args)]
17959 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
17960 }
17961 if let Some(v) = self.pk_scan_range.as_ref() {
17962 struct_ser.serialize_field("pkScanRange", v)?;
17963 }
17964 struct_ser.end()
17965 }
17966}
17967impl<'de> serde::Deserialize<'de> for StreamScanNode {
17968 #[allow(deprecated)]
17969 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17970 where
17971 D: serde::Deserializer<'de>,
17972 {
17973 const FIELDS: &[&str] = &[
17974 "table_id",
17975 "tableId",
17976 "upstream_column_ids",
17977 "upstreamColumnIds",
17978 "output_indices",
17979 "outputIndices",
17980 "stream_scan_type",
17981 "streamScanType",
17982 "state_table",
17983 "stateTable",
17984 "table_desc",
17985 "tableDesc",
17986 "rate_limit",
17987 "rateLimit",
17988 "snapshot_read_barrier_interval",
17989 "snapshotReadBarrierInterval",
17990 "arrangement_table",
17991 "arrangementTable",
17992 "snapshot_backfill_epoch",
17993 "snapshotBackfillEpoch",
17994 "pk_scan_range",
17995 "pkScanRange",
17996 ];
17997
17998 #[allow(clippy::enum_variant_names)]
17999 enum GeneratedField {
18000 TableId,
18001 UpstreamColumnIds,
18002 OutputIndices,
18003 StreamScanType,
18004 StateTable,
18005 TableDesc,
18006 RateLimit,
18007 SnapshotReadBarrierInterval,
18008 ArrangementTable,
18009 SnapshotBackfillEpoch,
18010 PkScanRange,
18011 }
18012 impl<'de> serde::Deserialize<'de> for GeneratedField {
18013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18014 where
18015 D: serde::Deserializer<'de>,
18016 {
18017 struct GeneratedVisitor;
18018
18019 impl serde::de::Visitor<'_> for GeneratedVisitor {
18020 type Value = GeneratedField;
18021
18022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18023 write!(formatter, "expected one of: {:?}", &FIELDS)
18024 }
18025
18026 #[allow(unused_variables)]
18027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18028 where
18029 E: serde::de::Error,
18030 {
18031 match value {
18032 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18033 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
18034 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
18035 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
18036 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
18037 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
18038 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
18039 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
18040 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
18041 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
18042 "pkScanRange" | "pk_scan_range" => Ok(GeneratedField::PkScanRange),
18043 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18044 }
18045 }
18046 }
18047 deserializer.deserialize_identifier(GeneratedVisitor)
18048 }
18049 }
18050 struct GeneratedVisitor;
18051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18052 type Value = StreamScanNode;
18053
18054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18055 formatter.write_str("struct stream_plan.StreamScanNode")
18056 }
18057
18058 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
18059 where
18060 V: serde::de::MapAccess<'de>,
18061 {
18062 let mut table_id__ = None;
18063 let mut upstream_column_ids__ = None;
18064 let mut output_indices__ = None;
18065 let mut stream_scan_type__ = None;
18066 let mut state_table__ = None;
18067 let mut table_desc__ = None;
18068 let mut rate_limit__ = None;
18069 let mut snapshot_read_barrier_interval__ = None;
18070 let mut arrangement_table__ = None;
18071 let mut snapshot_backfill_epoch__ = None;
18072 let mut pk_scan_range__ = None;
18073 while let Some(k) = map_.next_key()? {
18074 match k {
18075 GeneratedField::TableId => {
18076 if table_id__.is_some() {
18077 return Err(serde::de::Error::duplicate_field("tableId"));
18078 }
18079 table_id__ =
18080 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18081 ;
18082 }
18083 GeneratedField::UpstreamColumnIds => {
18084 if upstream_column_ids__.is_some() {
18085 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
18086 }
18087 upstream_column_ids__ =
18088 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18089 .into_iter().map(|x| x.0).collect())
18090 ;
18091 }
18092 GeneratedField::OutputIndices => {
18093 if output_indices__.is_some() {
18094 return Err(serde::de::Error::duplicate_field("outputIndices"));
18095 }
18096 output_indices__ =
18097 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18098 .into_iter().map(|x| x.0).collect())
18099 ;
18100 }
18101 GeneratedField::StreamScanType => {
18102 if stream_scan_type__.is_some() {
18103 return Err(serde::de::Error::duplicate_field("streamScanType"));
18104 }
18105 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
18106 }
18107 GeneratedField::StateTable => {
18108 if state_table__.is_some() {
18109 return Err(serde::de::Error::duplicate_field("stateTable"));
18110 }
18111 state_table__ = map_.next_value()?;
18112 }
18113 GeneratedField::TableDesc => {
18114 if table_desc__.is_some() {
18115 return Err(serde::de::Error::duplicate_field("tableDesc"));
18116 }
18117 table_desc__ = map_.next_value()?;
18118 }
18119 GeneratedField::RateLimit => {
18120 if rate_limit__.is_some() {
18121 return Err(serde::de::Error::duplicate_field("rateLimit"));
18122 }
18123 rate_limit__ =
18124 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18125 ;
18126 }
18127 GeneratedField::SnapshotReadBarrierInterval => {
18128 if snapshot_read_barrier_interval__.is_some() {
18129 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
18130 }
18131 snapshot_read_barrier_interval__ =
18132 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18133 ;
18134 }
18135 GeneratedField::ArrangementTable => {
18136 if arrangement_table__.is_some() {
18137 return Err(serde::de::Error::duplicate_field("arrangementTable"));
18138 }
18139 arrangement_table__ = map_.next_value()?;
18140 }
18141 GeneratedField::SnapshotBackfillEpoch => {
18142 if snapshot_backfill_epoch__.is_some() {
18143 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
18144 }
18145 snapshot_backfill_epoch__ =
18146 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18147 ;
18148 }
18149 GeneratedField::PkScanRange => {
18150 if pk_scan_range__.is_some() {
18151 return Err(serde::de::Error::duplicate_field("pkScanRange"));
18152 }
18153 pk_scan_range__ = map_.next_value()?;
18154 }
18155 }
18156 }
18157 Ok(StreamScanNode {
18158 table_id: table_id__.unwrap_or_default(),
18159 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
18160 output_indices: output_indices__.unwrap_or_default(),
18161 stream_scan_type: stream_scan_type__.unwrap_or_default(),
18162 state_table: state_table__,
18163 table_desc: table_desc__,
18164 rate_limit: rate_limit__,
18165 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
18166 arrangement_table: arrangement_table__,
18167 snapshot_backfill_epoch: snapshot_backfill_epoch__,
18168 pk_scan_range: pk_scan_range__,
18169 })
18170 }
18171 }
18172 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
18173 }
18174}
18175impl serde::Serialize for StreamScanType {
18176 #[allow(deprecated)]
18177 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18178 where
18179 S: serde::Serializer,
18180 {
18181 let variant = match self {
18182 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
18183 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
18184 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
18185 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
18186 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
18187 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
18188 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
18189 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
18190 };
18191 serializer.serialize_str(variant)
18192 }
18193}
18194impl<'de> serde::Deserialize<'de> for StreamScanType {
18195 #[allow(deprecated)]
18196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18197 where
18198 D: serde::Deserializer<'de>,
18199 {
18200 const FIELDS: &[&str] = &[
18201 "STREAM_SCAN_TYPE_UNSPECIFIED",
18202 "STREAM_SCAN_TYPE_CHAIN",
18203 "STREAM_SCAN_TYPE_REARRANGE",
18204 "STREAM_SCAN_TYPE_BACKFILL",
18205 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
18206 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
18207 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
18208 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
18209 ];
18210
18211 struct GeneratedVisitor;
18212
18213 impl serde::de::Visitor<'_> for GeneratedVisitor {
18214 type Value = StreamScanType;
18215
18216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18217 write!(formatter, "expected one of: {:?}", &FIELDS)
18218 }
18219
18220 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18221 where
18222 E: serde::de::Error,
18223 {
18224 i32::try_from(v)
18225 .ok()
18226 .and_then(|x| x.try_into().ok())
18227 .ok_or_else(|| {
18228 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18229 })
18230 }
18231
18232 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18233 where
18234 E: serde::de::Error,
18235 {
18236 i32::try_from(v)
18237 .ok()
18238 .and_then(|x| x.try_into().ok())
18239 .ok_or_else(|| {
18240 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18241 })
18242 }
18243
18244 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18245 where
18246 E: serde::de::Error,
18247 {
18248 match value {
18249 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
18250 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
18251 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
18252 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
18253 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
18254 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
18255 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
18256 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
18257 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18258 }
18259 }
18260 }
18261 deserializer.deserialize_any(GeneratedVisitor)
18262 }
18263}
18264impl serde::Serialize for StreamSource {
18265 #[allow(deprecated)]
18266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18267 where
18268 S: serde::Serializer,
18269 {
18270 use serde::ser::SerializeStruct;
18271 let mut len = 0;
18272 if self.source_id != 0 {
18273 len += 1;
18274 }
18275 if self.state_table.is_some() {
18276 len += 1;
18277 }
18278 if self.row_id_index.is_some() {
18279 len += 1;
18280 }
18281 if !self.columns.is_empty() {
18282 len += 1;
18283 }
18284 if !self.with_properties.is_empty() {
18285 len += 1;
18286 }
18287 if self.info.is_some() {
18288 len += 1;
18289 }
18290 if !self.source_name.is_empty() {
18291 len += 1;
18292 }
18293 if self.rate_limit.is_some() {
18294 len += 1;
18295 }
18296 if !self.secret_refs.is_empty() {
18297 len += 1;
18298 }
18299 if self.downstream_columns.is_some() {
18300 len += 1;
18301 }
18302 if self.refresh_mode.is_some() {
18303 len += 1;
18304 }
18305 if self.associated_table_id.is_some() {
18306 len += 1;
18307 }
18308 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
18309 if self.source_id != 0 {
18310 struct_ser.serialize_field("sourceId", &self.source_id)?;
18311 }
18312 if let Some(v) = self.state_table.as_ref() {
18313 struct_ser.serialize_field("stateTable", v)?;
18314 }
18315 if let Some(v) = self.row_id_index.as_ref() {
18316 struct_ser.serialize_field("rowIdIndex", v)?;
18317 }
18318 if !self.columns.is_empty() {
18319 struct_ser.serialize_field("columns", &self.columns)?;
18320 }
18321 if !self.with_properties.is_empty() {
18322 struct_ser.serialize_field("withProperties", &self.with_properties)?;
18323 }
18324 if let Some(v) = self.info.as_ref() {
18325 struct_ser.serialize_field("info", v)?;
18326 }
18327 if !self.source_name.is_empty() {
18328 struct_ser.serialize_field("sourceName", &self.source_name)?;
18329 }
18330 if let Some(v) = self.rate_limit.as_ref() {
18331 struct_ser.serialize_field("rateLimit", v)?;
18332 }
18333 if !self.secret_refs.is_empty() {
18334 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
18335 }
18336 if let Some(v) = self.downstream_columns.as_ref() {
18337 struct_ser.serialize_field("downstreamColumns", v)?;
18338 }
18339 if let Some(v) = self.refresh_mode.as_ref() {
18340 struct_ser.serialize_field("refreshMode", v)?;
18341 }
18342 if let Some(v) = self.associated_table_id.as_ref() {
18343 struct_ser.serialize_field("associatedTableId", v)?;
18344 }
18345 struct_ser.end()
18346 }
18347}
18348impl<'de> serde::Deserialize<'de> for StreamSource {
18349 #[allow(deprecated)]
18350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18351 where
18352 D: serde::Deserializer<'de>,
18353 {
18354 const FIELDS: &[&str] = &[
18355 "source_id",
18356 "sourceId",
18357 "state_table",
18358 "stateTable",
18359 "row_id_index",
18360 "rowIdIndex",
18361 "columns",
18362 "with_properties",
18363 "withProperties",
18364 "info",
18365 "source_name",
18366 "sourceName",
18367 "rate_limit",
18368 "rateLimit",
18369 "secret_refs",
18370 "secretRefs",
18371 "downstream_columns",
18372 "downstreamColumns",
18373 "refresh_mode",
18374 "refreshMode",
18375 "associated_table_id",
18376 "associatedTableId",
18377 ];
18378
18379 #[allow(clippy::enum_variant_names)]
18380 enum GeneratedField {
18381 SourceId,
18382 StateTable,
18383 RowIdIndex,
18384 Columns,
18385 WithProperties,
18386 Info,
18387 SourceName,
18388 RateLimit,
18389 SecretRefs,
18390 DownstreamColumns,
18391 RefreshMode,
18392 AssociatedTableId,
18393 }
18394 impl<'de> serde::Deserialize<'de> for GeneratedField {
18395 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18396 where
18397 D: serde::Deserializer<'de>,
18398 {
18399 struct GeneratedVisitor;
18400
18401 impl serde::de::Visitor<'_> for GeneratedVisitor {
18402 type Value = GeneratedField;
18403
18404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18405 write!(formatter, "expected one of: {:?}", &FIELDS)
18406 }
18407
18408 #[allow(unused_variables)]
18409 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18410 where
18411 E: serde::de::Error,
18412 {
18413 match value {
18414 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
18415 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
18416 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
18417 "columns" => Ok(GeneratedField::Columns),
18418 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
18419 "info" => Ok(GeneratedField::Info),
18420 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
18421 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
18422 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
18423 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
18424 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
18425 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
18426 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18427 }
18428 }
18429 }
18430 deserializer.deserialize_identifier(GeneratedVisitor)
18431 }
18432 }
18433 struct GeneratedVisitor;
18434 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18435 type Value = StreamSource;
18436
18437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18438 formatter.write_str("struct stream_plan.StreamSource")
18439 }
18440
18441 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
18442 where
18443 V: serde::de::MapAccess<'de>,
18444 {
18445 let mut source_id__ = None;
18446 let mut state_table__ = None;
18447 let mut row_id_index__ = None;
18448 let mut columns__ = None;
18449 let mut with_properties__ = None;
18450 let mut info__ = None;
18451 let mut source_name__ = None;
18452 let mut rate_limit__ = None;
18453 let mut secret_refs__ = None;
18454 let mut downstream_columns__ = None;
18455 let mut refresh_mode__ = None;
18456 let mut associated_table_id__ = None;
18457 while let Some(k) = map_.next_key()? {
18458 match k {
18459 GeneratedField::SourceId => {
18460 if source_id__.is_some() {
18461 return Err(serde::de::Error::duplicate_field("sourceId"));
18462 }
18463 source_id__ =
18464 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18465 ;
18466 }
18467 GeneratedField::StateTable => {
18468 if state_table__.is_some() {
18469 return Err(serde::de::Error::duplicate_field("stateTable"));
18470 }
18471 state_table__ = map_.next_value()?;
18472 }
18473 GeneratedField::RowIdIndex => {
18474 if row_id_index__.is_some() {
18475 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
18476 }
18477 row_id_index__ =
18478 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18479 ;
18480 }
18481 GeneratedField::Columns => {
18482 if columns__.is_some() {
18483 return Err(serde::de::Error::duplicate_field("columns"));
18484 }
18485 columns__ = Some(map_.next_value()?);
18486 }
18487 GeneratedField::WithProperties => {
18488 if with_properties__.is_some() {
18489 return Err(serde::de::Error::duplicate_field("withProperties"));
18490 }
18491 with_properties__ = Some(
18492 map_.next_value::<std::collections::BTreeMap<_, _>>()?
18493 );
18494 }
18495 GeneratedField::Info => {
18496 if info__.is_some() {
18497 return Err(serde::de::Error::duplicate_field("info"));
18498 }
18499 info__ = map_.next_value()?;
18500 }
18501 GeneratedField::SourceName => {
18502 if source_name__.is_some() {
18503 return Err(serde::de::Error::duplicate_field("sourceName"));
18504 }
18505 source_name__ = Some(map_.next_value()?);
18506 }
18507 GeneratedField::RateLimit => {
18508 if rate_limit__.is_some() {
18509 return Err(serde::de::Error::duplicate_field("rateLimit"));
18510 }
18511 rate_limit__ =
18512 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18513 ;
18514 }
18515 GeneratedField::SecretRefs => {
18516 if secret_refs__.is_some() {
18517 return Err(serde::de::Error::duplicate_field("secretRefs"));
18518 }
18519 secret_refs__ = Some(
18520 map_.next_value::<std::collections::BTreeMap<_, _>>()?
18521 );
18522 }
18523 GeneratedField::DownstreamColumns => {
18524 if downstream_columns__.is_some() {
18525 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
18526 }
18527 downstream_columns__ = map_.next_value()?;
18528 }
18529 GeneratedField::RefreshMode => {
18530 if refresh_mode__.is_some() {
18531 return Err(serde::de::Error::duplicate_field("refreshMode"));
18532 }
18533 refresh_mode__ = map_.next_value()?;
18534 }
18535 GeneratedField::AssociatedTableId => {
18536 if associated_table_id__.is_some() {
18537 return Err(serde::de::Error::duplicate_field("associatedTableId"));
18538 }
18539 associated_table_id__ =
18540 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18541 ;
18542 }
18543 }
18544 }
18545 Ok(StreamSource {
18546 source_id: source_id__.unwrap_or_default(),
18547 state_table: state_table__,
18548 row_id_index: row_id_index__,
18549 columns: columns__.unwrap_or_default(),
18550 with_properties: with_properties__.unwrap_or_default(),
18551 info: info__,
18552 source_name: source_name__.unwrap_or_default(),
18553 rate_limit: rate_limit__,
18554 secret_refs: secret_refs__.unwrap_or_default(),
18555 downstream_columns: downstream_columns__,
18556 refresh_mode: refresh_mode__,
18557 associated_table_id: associated_table_id__,
18558 })
18559 }
18560 }
18561 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
18562 }
18563}
18564impl serde::Serialize for SubscriptionUpstreamInfo {
18565 #[allow(deprecated)]
18566 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18567 where
18568 S: serde::Serializer,
18569 {
18570 use serde::ser::SerializeStruct;
18571 let mut len = 0;
18572 if self.subscriber_id != 0 {
18573 len += 1;
18574 }
18575 if self.upstream_mv_table_id != 0 {
18576 len += 1;
18577 }
18578 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
18579 if self.subscriber_id != 0 {
18580 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
18581 }
18582 if self.upstream_mv_table_id != 0 {
18583 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
18584 }
18585 struct_ser.end()
18586 }
18587}
18588impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
18589 #[allow(deprecated)]
18590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18591 where
18592 D: serde::Deserializer<'de>,
18593 {
18594 const FIELDS: &[&str] = &[
18595 "subscriber_id",
18596 "subscriberId",
18597 "upstream_mv_table_id",
18598 "upstreamMvTableId",
18599 ];
18600
18601 #[allow(clippy::enum_variant_names)]
18602 enum GeneratedField {
18603 SubscriberId,
18604 UpstreamMvTableId,
18605 }
18606 impl<'de> serde::Deserialize<'de> for GeneratedField {
18607 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18608 where
18609 D: serde::Deserializer<'de>,
18610 {
18611 struct GeneratedVisitor;
18612
18613 impl serde::de::Visitor<'_> for GeneratedVisitor {
18614 type Value = GeneratedField;
18615
18616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18617 write!(formatter, "expected one of: {:?}", &FIELDS)
18618 }
18619
18620 #[allow(unused_variables)]
18621 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18622 where
18623 E: serde::de::Error,
18624 {
18625 match value {
18626 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
18627 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
18628 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18629 }
18630 }
18631 }
18632 deserializer.deserialize_identifier(GeneratedVisitor)
18633 }
18634 }
18635 struct GeneratedVisitor;
18636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18637 type Value = SubscriptionUpstreamInfo;
18638
18639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18640 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
18641 }
18642
18643 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
18644 where
18645 V: serde::de::MapAccess<'de>,
18646 {
18647 let mut subscriber_id__ = None;
18648 let mut upstream_mv_table_id__ = None;
18649 while let Some(k) = map_.next_key()? {
18650 match k {
18651 GeneratedField::SubscriberId => {
18652 if subscriber_id__.is_some() {
18653 return Err(serde::de::Error::duplicate_field("subscriberId"));
18654 }
18655 subscriber_id__ =
18656 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18657 ;
18658 }
18659 GeneratedField::UpstreamMvTableId => {
18660 if upstream_mv_table_id__.is_some() {
18661 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
18662 }
18663 upstream_mv_table_id__ =
18664 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18665 ;
18666 }
18667 }
18668 }
18669 Ok(SubscriptionUpstreamInfo {
18670 subscriber_id: subscriber_id__.unwrap_or_default(),
18671 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
18672 })
18673 }
18674 }
18675 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
18676 }
18677}
18678impl serde::Serialize for SyncLogStoreNode {
18679 #[allow(deprecated)]
18680 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18681 where
18682 S: serde::Serializer,
18683 {
18684 use serde::ser::SerializeStruct;
18685 let mut len = 0;
18686 if self.log_store_table.is_some() {
18687 len += 1;
18688 }
18689 if self.pause_duration_ms.is_some() {
18690 len += 1;
18691 }
18692 if self.buffer_size.is_some() {
18693 len += 1;
18694 }
18695 if self.aligned {
18696 len += 1;
18697 }
18698 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
18699 if let Some(v) = self.log_store_table.as_ref() {
18700 struct_ser.serialize_field("logStoreTable", v)?;
18701 }
18702 if let Some(v) = self.pause_duration_ms.as_ref() {
18703 struct_ser.serialize_field("pauseDurationMs", v)?;
18704 }
18705 if let Some(v) = self.buffer_size.as_ref() {
18706 struct_ser.serialize_field("bufferSize", v)?;
18707 }
18708 if self.aligned {
18709 struct_ser.serialize_field("aligned", &self.aligned)?;
18710 }
18711 struct_ser.end()
18712 }
18713}
18714impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
18715 #[allow(deprecated)]
18716 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18717 where
18718 D: serde::Deserializer<'de>,
18719 {
18720 const FIELDS: &[&str] = &[
18721 "log_store_table",
18722 "logStoreTable",
18723 "pause_duration_ms",
18724 "pauseDurationMs",
18725 "buffer_size",
18726 "bufferSize",
18727 "aligned",
18728 ];
18729
18730 #[allow(clippy::enum_variant_names)]
18731 enum GeneratedField {
18732 LogStoreTable,
18733 PauseDurationMs,
18734 BufferSize,
18735 Aligned,
18736 }
18737 impl<'de> serde::Deserialize<'de> for GeneratedField {
18738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18739 where
18740 D: serde::Deserializer<'de>,
18741 {
18742 struct GeneratedVisitor;
18743
18744 impl serde::de::Visitor<'_> for GeneratedVisitor {
18745 type Value = GeneratedField;
18746
18747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18748 write!(formatter, "expected one of: {:?}", &FIELDS)
18749 }
18750
18751 #[allow(unused_variables)]
18752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18753 where
18754 E: serde::de::Error,
18755 {
18756 match value {
18757 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
18758 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
18759 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
18760 "aligned" => Ok(GeneratedField::Aligned),
18761 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18762 }
18763 }
18764 }
18765 deserializer.deserialize_identifier(GeneratedVisitor)
18766 }
18767 }
18768 struct GeneratedVisitor;
18769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18770 type Value = SyncLogStoreNode;
18771
18772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18773 formatter.write_str("struct stream_plan.SyncLogStoreNode")
18774 }
18775
18776 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
18777 where
18778 V: serde::de::MapAccess<'de>,
18779 {
18780 let mut log_store_table__ = None;
18781 let mut pause_duration_ms__ = None;
18782 let mut buffer_size__ = None;
18783 let mut aligned__ = None;
18784 while let Some(k) = map_.next_key()? {
18785 match k {
18786 GeneratedField::LogStoreTable => {
18787 if log_store_table__.is_some() {
18788 return Err(serde::de::Error::duplicate_field("logStoreTable"));
18789 }
18790 log_store_table__ = map_.next_value()?;
18791 }
18792 GeneratedField::PauseDurationMs => {
18793 if pause_duration_ms__.is_some() {
18794 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
18795 }
18796 pause_duration_ms__ =
18797 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18798 ;
18799 }
18800 GeneratedField::BufferSize => {
18801 if buffer_size__.is_some() {
18802 return Err(serde::de::Error::duplicate_field("bufferSize"));
18803 }
18804 buffer_size__ =
18805 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18806 ;
18807 }
18808 GeneratedField::Aligned => {
18809 if aligned__.is_some() {
18810 return Err(serde::de::Error::duplicate_field("aligned"));
18811 }
18812 aligned__ = Some(map_.next_value()?);
18813 }
18814 }
18815 }
18816 Ok(SyncLogStoreNode {
18817 log_store_table: log_store_table__,
18818 pause_duration_ms: pause_duration_ms__,
18819 buffer_size: buffer_size__,
18820 aligned: aligned__.unwrap_or_default(),
18821 })
18822 }
18823 }
18824 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
18825 }
18826}
18827impl serde::Serialize for TemporalJoinNode {
18828 #[allow(deprecated)]
18829 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18830 where
18831 S: serde::Serializer,
18832 {
18833 use serde::ser::SerializeStruct;
18834 let mut len = 0;
18835 if self.join_type != 0 {
18836 len += 1;
18837 }
18838 if !self.left_key.is_empty() {
18839 len += 1;
18840 }
18841 if !self.right_key.is_empty() {
18842 len += 1;
18843 }
18844 if !self.null_safe.is_empty() {
18845 len += 1;
18846 }
18847 if self.condition.is_some() {
18848 len += 1;
18849 }
18850 if !self.output_indices.is_empty() {
18851 len += 1;
18852 }
18853 if self.table_desc.is_some() {
18854 len += 1;
18855 }
18856 if !self.table_output_indices.is_empty() {
18857 len += 1;
18858 }
18859 if self.memo_table.is_some() {
18860 len += 1;
18861 }
18862 if self.is_nested_loop {
18863 len += 1;
18864 }
18865 if self.is_broadcast {
18866 len += 1;
18867 }
18868 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
18869 if self.join_type != 0 {
18870 let v = super::plan_common::JoinType::try_from(self.join_type)
18871 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
18872 struct_ser.serialize_field("joinType", &v)?;
18873 }
18874 if !self.left_key.is_empty() {
18875 struct_ser.serialize_field("leftKey", &self.left_key)?;
18876 }
18877 if !self.right_key.is_empty() {
18878 struct_ser.serialize_field("rightKey", &self.right_key)?;
18879 }
18880 if !self.null_safe.is_empty() {
18881 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
18882 }
18883 if let Some(v) = self.condition.as_ref() {
18884 struct_ser.serialize_field("condition", v)?;
18885 }
18886 if !self.output_indices.is_empty() {
18887 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
18888 }
18889 if let Some(v) = self.table_desc.as_ref() {
18890 struct_ser.serialize_field("tableDesc", v)?;
18891 }
18892 if !self.table_output_indices.is_empty() {
18893 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
18894 }
18895 if let Some(v) = self.memo_table.as_ref() {
18896 struct_ser.serialize_field("memoTable", v)?;
18897 }
18898 if self.is_nested_loop {
18899 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
18900 }
18901 if self.is_broadcast {
18902 struct_ser.serialize_field("isBroadcast", &self.is_broadcast)?;
18903 }
18904 struct_ser.end()
18905 }
18906}
18907impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
18908 #[allow(deprecated)]
18909 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18910 where
18911 D: serde::Deserializer<'de>,
18912 {
18913 const FIELDS: &[&str] = &[
18914 "join_type",
18915 "joinType",
18916 "left_key",
18917 "leftKey",
18918 "right_key",
18919 "rightKey",
18920 "null_safe",
18921 "nullSafe",
18922 "condition",
18923 "output_indices",
18924 "outputIndices",
18925 "table_desc",
18926 "tableDesc",
18927 "table_output_indices",
18928 "tableOutputIndices",
18929 "memo_table",
18930 "memoTable",
18931 "is_nested_loop",
18932 "isNestedLoop",
18933 "is_broadcast",
18934 "isBroadcast",
18935 ];
18936
18937 #[allow(clippy::enum_variant_names)]
18938 enum GeneratedField {
18939 JoinType,
18940 LeftKey,
18941 RightKey,
18942 NullSafe,
18943 Condition,
18944 OutputIndices,
18945 TableDesc,
18946 TableOutputIndices,
18947 MemoTable,
18948 IsNestedLoop,
18949 IsBroadcast,
18950 }
18951 impl<'de> serde::Deserialize<'de> for GeneratedField {
18952 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18953 where
18954 D: serde::Deserializer<'de>,
18955 {
18956 struct GeneratedVisitor;
18957
18958 impl serde::de::Visitor<'_> for GeneratedVisitor {
18959 type Value = GeneratedField;
18960
18961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18962 write!(formatter, "expected one of: {:?}", &FIELDS)
18963 }
18964
18965 #[allow(unused_variables)]
18966 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18967 where
18968 E: serde::de::Error,
18969 {
18970 match value {
18971 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
18972 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
18973 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
18974 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
18975 "condition" => Ok(GeneratedField::Condition),
18976 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
18977 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
18978 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
18979 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
18980 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
18981 "isBroadcast" | "is_broadcast" => Ok(GeneratedField::IsBroadcast),
18982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18983 }
18984 }
18985 }
18986 deserializer.deserialize_identifier(GeneratedVisitor)
18987 }
18988 }
18989 struct GeneratedVisitor;
18990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18991 type Value = TemporalJoinNode;
18992
18993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18994 formatter.write_str("struct stream_plan.TemporalJoinNode")
18995 }
18996
18997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
18998 where
18999 V: serde::de::MapAccess<'de>,
19000 {
19001 let mut join_type__ = None;
19002 let mut left_key__ = None;
19003 let mut right_key__ = None;
19004 let mut null_safe__ = None;
19005 let mut condition__ = None;
19006 let mut output_indices__ = None;
19007 let mut table_desc__ = None;
19008 let mut table_output_indices__ = None;
19009 let mut memo_table__ = None;
19010 let mut is_nested_loop__ = None;
19011 let mut is_broadcast__ = None;
19012 while let Some(k) = map_.next_key()? {
19013 match k {
19014 GeneratedField::JoinType => {
19015 if join_type__.is_some() {
19016 return Err(serde::de::Error::duplicate_field("joinType"));
19017 }
19018 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
19019 }
19020 GeneratedField::LeftKey => {
19021 if left_key__.is_some() {
19022 return Err(serde::de::Error::duplicate_field("leftKey"));
19023 }
19024 left_key__ =
19025 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19026 .into_iter().map(|x| x.0).collect())
19027 ;
19028 }
19029 GeneratedField::RightKey => {
19030 if right_key__.is_some() {
19031 return Err(serde::de::Error::duplicate_field("rightKey"));
19032 }
19033 right_key__ =
19034 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19035 .into_iter().map(|x| x.0).collect())
19036 ;
19037 }
19038 GeneratedField::NullSafe => {
19039 if null_safe__.is_some() {
19040 return Err(serde::de::Error::duplicate_field("nullSafe"));
19041 }
19042 null_safe__ = Some(map_.next_value()?);
19043 }
19044 GeneratedField::Condition => {
19045 if condition__.is_some() {
19046 return Err(serde::de::Error::duplicate_field("condition"));
19047 }
19048 condition__ = map_.next_value()?;
19049 }
19050 GeneratedField::OutputIndices => {
19051 if output_indices__.is_some() {
19052 return Err(serde::de::Error::duplicate_field("outputIndices"));
19053 }
19054 output_indices__ =
19055 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19056 .into_iter().map(|x| x.0).collect())
19057 ;
19058 }
19059 GeneratedField::TableDesc => {
19060 if table_desc__.is_some() {
19061 return Err(serde::de::Error::duplicate_field("tableDesc"));
19062 }
19063 table_desc__ = map_.next_value()?;
19064 }
19065 GeneratedField::TableOutputIndices => {
19066 if table_output_indices__.is_some() {
19067 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
19068 }
19069 table_output_indices__ =
19070 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19071 .into_iter().map(|x| x.0).collect())
19072 ;
19073 }
19074 GeneratedField::MemoTable => {
19075 if memo_table__.is_some() {
19076 return Err(serde::de::Error::duplicate_field("memoTable"));
19077 }
19078 memo_table__ = map_.next_value()?;
19079 }
19080 GeneratedField::IsNestedLoop => {
19081 if is_nested_loop__.is_some() {
19082 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
19083 }
19084 is_nested_loop__ = Some(map_.next_value()?);
19085 }
19086 GeneratedField::IsBroadcast => {
19087 if is_broadcast__.is_some() {
19088 return Err(serde::de::Error::duplicate_field("isBroadcast"));
19089 }
19090 is_broadcast__ = Some(map_.next_value()?);
19091 }
19092 }
19093 }
19094 Ok(TemporalJoinNode {
19095 join_type: join_type__.unwrap_or_default(),
19096 left_key: left_key__.unwrap_or_default(),
19097 right_key: right_key__.unwrap_or_default(),
19098 null_safe: null_safe__.unwrap_or_default(),
19099 condition: condition__,
19100 output_indices: output_indices__.unwrap_or_default(),
19101 table_desc: table_desc__,
19102 table_output_indices: table_output_indices__.unwrap_or_default(),
19103 memo_table: memo_table__,
19104 is_nested_loop: is_nested_loop__.unwrap_or_default(),
19105 is_broadcast: is_broadcast__.unwrap_or_default(),
19106 })
19107 }
19108 }
19109 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
19110 }
19111}
19112impl serde::Serialize for ThrottleMutation {
19113 #[allow(deprecated)]
19114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19115 where
19116 S: serde::Serializer,
19117 {
19118 use serde::ser::SerializeStruct;
19119 let mut len = 0;
19120 if !self.fragment_throttle.is_empty() {
19121 len += 1;
19122 }
19123 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
19124 if !self.fragment_throttle.is_empty() {
19125 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
19126 }
19127 struct_ser.end()
19128 }
19129}
19130impl<'de> serde::Deserialize<'de> for ThrottleMutation {
19131 #[allow(deprecated)]
19132 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19133 where
19134 D: serde::Deserializer<'de>,
19135 {
19136 const FIELDS: &[&str] = &[
19137 "fragment_throttle",
19138 "fragmentThrottle",
19139 ];
19140
19141 #[allow(clippy::enum_variant_names)]
19142 enum GeneratedField {
19143 FragmentThrottle,
19144 }
19145 impl<'de> serde::Deserialize<'de> for GeneratedField {
19146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19147 where
19148 D: serde::Deserializer<'de>,
19149 {
19150 struct GeneratedVisitor;
19151
19152 impl serde::de::Visitor<'_> for GeneratedVisitor {
19153 type Value = GeneratedField;
19154
19155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19156 write!(formatter, "expected one of: {:?}", &FIELDS)
19157 }
19158
19159 #[allow(unused_variables)]
19160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19161 where
19162 E: serde::de::Error,
19163 {
19164 match value {
19165 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
19166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19167 }
19168 }
19169 }
19170 deserializer.deserialize_identifier(GeneratedVisitor)
19171 }
19172 }
19173 struct GeneratedVisitor;
19174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19175 type Value = ThrottleMutation;
19176
19177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19178 formatter.write_str("struct stream_plan.ThrottleMutation")
19179 }
19180
19181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
19182 where
19183 V: serde::de::MapAccess<'de>,
19184 {
19185 let mut fragment_throttle__ = None;
19186 while let Some(k) = map_.next_key()? {
19187 match k {
19188 GeneratedField::FragmentThrottle => {
19189 if fragment_throttle__.is_some() {
19190 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
19191 }
19192 fragment_throttle__ = Some(
19193 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19194 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19195 );
19196 }
19197 }
19198 }
19199 Ok(ThrottleMutation {
19200 fragment_throttle: fragment_throttle__.unwrap_or_default(),
19201 })
19202 }
19203 }
19204 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
19205 }
19206}
19207impl serde::Serialize for throttle_mutation::ThrottleConfig {
19208 #[allow(deprecated)]
19209 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19210 where
19211 S: serde::Serializer,
19212 {
19213 use serde::ser::SerializeStruct;
19214 let mut len = 0;
19215 if self.rate_limit.is_some() {
19216 len += 1;
19217 }
19218 if self.throttle_type != 0 {
19219 len += 1;
19220 }
19221 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
19222 if let Some(v) = self.rate_limit.as_ref() {
19223 struct_ser.serialize_field("rateLimit", v)?;
19224 }
19225 if self.throttle_type != 0 {
19226 let v = super::common::ThrottleType::try_from(self.throttle_type)
19227 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
19228 struct_ser.serialize_field("throttleType", &v)?;
19229 }
19230 struct_ser.end()
19231 }
19232}
19233impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
19234 #[allow(deprecated)]
19235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19236 where
19237 D: serde::Deserializer<'de>,
19238 {
19239 const FIELDS: &[&str] = &[
19240 "rate_limit",
19241 "rateLimit",
19242 "throttle_type",
19243 "throttleType",
19244 ];
19245
19246 #[allow(clippy::enum_variant_names)]
19247 enum GeneratedField {
19248 RateLimit,
19249 ThrottleType,
19250 }
19251 impl<'de> serde::Deserialize<'de> for GeneratedField {
19252 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19253 where
19254 D: serde::Deserializer<'de>,
19255 {
19256 struct GeneratedVisitor;
19257
19258 impl serde::de::Visitor<'_> for GeneratedVisitor {
19259 type Value = GeneratedField;
19260
19261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19262 write!(formatter, "expected one of: {:?}", &FIELDS)
19263 }
19264
19265 #[allow(unused_variables)]
19266 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19267 where
19268 E: serde::de::Error,
19269 {
19270 match value {
19271 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
19272 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
19273 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19274 }
19275 }
19276 }
19277 deserializer.deserialize_identifier(GeneratedVisitor)
19278 }
19279 }
19280 struct GeneratedVisitor;
19281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19282 type Value = throttle_mutation::ThrottleConfig;
19283
19284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19285 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
19286 }
19287
19288 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
19289 where
19290 V: serde::de::MapAccess<'de>,
19291 {
19292 let mut rate_limit__ = None;
19293 let mut throttle_type__ = None;
19294 while let Some(k) = map_.next_key()? {
19295 match k {
19296 GeneratedField::RateLimit => {
19297 if rate_limit__.is_some() {
19298 return Err(serde::de::Error::duplicate_field("rateLimit"));
19299 }
19300 rate_limit__ =
19301 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
19302 ;
19303 }
19304 GeneratedField::ThrottleType => {
19305 if throttle_type__.is_some() {
19306 return Err(serde::de::Error::duplicate_field("throttleType"));
19307 }
19308 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
19309 }
19310 }
19311 }
19312 Ok(throttle_mutation::ThrottleConfig {
19313 rate_limit: rate_limit__,
19314 throttle_type: throttle_type__.unwrap_or_default(),
19315 })
19316 }
19317 }
19318 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
19319 }
19320}
19321impl serde::Serialize for TopNNode {
19322 #[allow(deprecated)]
19323 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19324 where
19325 S: serde::Serializer,
19326 {
19327 use serde::ser::SerializeStruct;
19328 let mut len = 0;
19329 if self.limit != 0 {
19330 len += 1;
19331 }
19332 if self.offset != 0 {
19333 len += 1;
19334 }
19335 if self.table.is_some() {
19336 len += 1;
19337 }
19338 if !self.order_by.is_empty() {
19339 len += 1;
19340 }
19341 if self.with_ties {
19342 len += 1;
19343 }
19344 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
19345 if self.limit != 0 {
19346 #[allow(clippy::needless_borrow)]
19347 #[allow(clippy::needless_borrows_for_generic_args)]
19348 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
19349 }
19350 if self.offset != 0 {
19351 #[allow(clippy::needless_borrow)]
19352 #[allow(clippy::needless_borrows_for_generic_args)]
19353 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
19354 }
19355 if let Some(v) = self.table.as_ref() {
19356 struct_ser.serialize_field("table", v)?;
19357 }
19358 if !self.order_by.is_empty() {
19359 struct_ser.serialize_field("orderBy", &self.order_by)?;
19360 }
19361 if self.with_ties {
19362 struct_ser.serialize_field("withTies", &self.with_ties)?;
19363 }
19364 struct_ser.end()
19365 }
19366}
19367impl<'de> serde::Deserialize<'de> for TopNNode {
19368 #[allow(deprecated)]
19369 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19370 where
19371 D: serde::Deserializer<'de>,
19372 {
19373 const FIELDS: &[&str] = &[
19374 "limit",
19375 "offset",
19376 "table",
19377 "order_by",
19378 "orderBy",
19379 "with_ties",
19380 "withTies",
19381 ];
19382
19383 #[allow(clippy::enum_variant_names)]
19384 enum GeneratedField {
19385 Limit,
19386 Offset,
19387 Table,
19388 OrderBy,
19389 WithTies,
19390 }
19391 impl<'de> serde::Deserialize<'de> for GeneratedField {
19392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19393 where
19394 D: serde::Deserializer<'de>,
19395 {
19396 struct GeneratedVisitor;
19397
19398 impl serde::de::Visitor<'_> for GeneratedVisitor {
19399 type Value = GeneratedField;
19400
19401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19402 write!(formatter, "expected one of: {:?}", &FIELDS)
19403 }
19404
19405 #[allow(unused_variables)]
19406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19407 where
19408 E: serde::de::Error,
19409 {
19410 match value {
19411 "limit" => Ok(GeneratedField::Limit),
19412 "offset" => Ok(GeneratedField::Offset),
19413 "table" => Ok(GeneratedField::Table),
19414 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
19415 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
19416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19417 }
19418 }
19419 }
19420 deserializer.deserialize_identifier(GeneratedVisitor)
19421 }
19422 }
19423 struct GeneratedVisitor;
19424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19425 type Value = TopNNode;
19426
19427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19428 formatter.write_str("struct stream_plan.TopNNode")
19429 }
19430
19431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
19432 where
19433 V: serde::de::MapAccess<'de>,
19434 {
19435 let mut limit__ = None;
19436 let mut offset__ = None;
19437 let mut table__ = None;
19438 let mut order_by__ = None;
19439 let mut with_ties__ = None;
19440 while let Some(k) = map_.next_key()? {
19441 match k {
19442 GeneratedField::Limit => {
19443 if limit__.is_some() {
19444 return Err(serde::de::Error::duplicate_field("limit"));
19445 }
19446 limit__ =
19447 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19448 ;
19449 }
19450 GeneratedField::Offset => {
19451 if offset__.is_some() {
19452 return Err(serde::de::Error::duplicate_field("offset"));
19453 }
19454 offset__ =
19455 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19456 ;
19457 }
19458 GeneratedField::Table => {
19459 if table__.is_some() {
19460 return Err(serde::de::Error::duplicate_field("table"));
19461 }
19462 table__ = map_.next_value()?;
19463 }
19464 GeneratedField::OrderBy => {
19465 if order_by__.is_some() {
19466 return Err(serde::de::Error::duplicate_field("orderBy"));
19467 }
19468 order_by__ = Some(map_.next_value()?);
19469 }
19470 GeneratedField::WithTies => {
19471 if with_ties__.is_some() {
19472 return Err(serde::de::Error::duplicate_field("withTies"));
19473 }
19474 with_ties__ = Some(map_.next_value()?);
19475 }
19476 }
19477 }
19478 Ok(TopNNode {
19479 limit: limit__.unwrap_or_default(),
19480 offset: offset__.unwrap_or_default(),
19481 table: table__,
19482 order_by: order_by__.unwrap_or_default(),
19483 with_ties: with_ties__.unwrap_or_default(),
19484 })
19485 }
19486 }
19487 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
19488 }
19489}
19490impl serde::Serialize for UnionNode {
19491 #[allow(deprecated)]
19492 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19493 where
19494 S: serde::Serializer,
19495 {
19496 use serde::ser::SerializeStruct;
19497 let len = 0;
19498 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
19499 struct_ser.end()
19500 }
19501}
19502impl<'de> serde::Deserialize<'de> for UnionNode {
19503 #[allow(deprecated)]
19504 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19505 where
19506 D: serde::Deserializer<'de>,
19507 {
19508 const FIELDS: &[&str] = &[
19509 ];
19510
19511 #[allow(clippy::enum_variant_names)]
19512 enum GeneratedField {
19513 }
19514 impl<'de> serde::Deserialize<'de> for GeneratedField {
19515 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19516 where
19517 D: serde::Deserializer<'de>,
19518 {
19519 struct GeneratedVisitor;
19520
19521 impl serde::de::Visitor<'_> for GeneratedVisitor {
19522 type Value = GeneratedField;
19523
19524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19525 write!(formatter, "expected one of: {:?}", &FIELDS)
19526 }
19527
19528 #[allow(unused_variables)]
19529 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19530 where
19531 E: serde::de::Error,
19532 {
19533 Err(serde::de::Error::unknown_field(value, FIELDS))
19534 }
19535 }
19536 deserializer.deserialize_identifier(GeneratedVisitor)
19537 }
19538 }
19539 struct GeneratedVisitor;
19540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19541 type Value = UnionNode;
19542
19543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19544 formatter.write_str("struct stream_plan.UnionNode")
19545 }
19546
19547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
19548 where
19549 V: serde::de::MapAccess<'de>,
19550 {
19551 while map_.next_key::<GeneratedField>()?.is_some() {
19552 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19553 }
19554 Ok(UnionNode {
19555 })
19556 }
19557 }
19558 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
19559 }
19560}
19561impl serde::Serialize for UpdateMutation {
19562 #[allow(deprecated)]
19563 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19564 where
19565 S: serde::Serializer,
19566 {
19567 use serde::ser::SerializeStruct;
19568 let mut len = 0;
19569 if !self.dispatcher_update.is_empty() {
19570 len += 1;
19571 }
19572 if !self.merge_update.is_empty() {
19573 len += 1;
19574 }
19575 if !self.actor_vnode_bitmap_update.is_empty() {
19576 len += 1;
19577 }
19578 if !self.dropped_actors.is_empty() {
19579 len += 1;
19580 }
19581 if !self.actor_splits.is_empty() {
19582 len += 1;
19583 }
19584 if !self.actor_new_dispatchers.is_empty() {
19585 len += 1;
19586 }
19587 if self.actor_cdc_table_snapshot_splits.is_some() {
19588 len += 1;
19589 }
19590 if !self.sink_schema_change.is_empty() {
19591 len += 1;
19592 }
19593 if !self.subscriptions_to_drop.is_empty() {
19594 len += 1;
19595 }
19596 if self.iceberg_pk_index_compaction.is_some() {
19597 len += 1;
19598 }
19599 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
19600 if !self.dispatcher_update.is_empty() {
19601 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
19602 }
19603 if !self.merge_update.is_empty() {
19604 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
19605 }
19606 if !self.actor_vnode_bitmap_update.is_empty() {
19607 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
19608 }
19609 if !self.dropped_actors.is_empty() {
19610 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
19611 }
19612 if !self.actor_splits.is_empty() {
19613 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
19614 }
19615 if !self.actor_new_dispatchers.is_empty() {
19616 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
19617 }
19618 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
19619 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
19620 }
19621 if !self.sink_schema_change.is_empty() {
19622 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
19623 }
19624 if !self.subscriptions_to_drop.is_empty() {
19625 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
19626 }
19627 if let Some(v) = self.iceberg_pk_index_compaction.as_ref() {
19628 struct_ser.serialize_field("icebergPkIndexCompaction", v)?;
19629 }
19630 struct_ser.end()
19631 }
19632}
19633impl<'de> serde::Deserialize<'de> for UpdateMutation {
19634 #[allow(deprecated)]
19635 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19636 where
19637 D: serde::Deserializer<'de>,
19638 {
19639 const FIELDS: &[&str] = &[
19640 "dispatcher_update",
19641 "dispatcherUpdate",
19642 "merge_update",
19643 "mergeUpdate",
19644 "actor_vnode_bitmap_update",
19645 "actorVnodeBitmapUpdate",
19646 "dropped_actors",
19647 "droppedActors",
19648 "actor_splits",
19649 "actorSplits",
19650 "actor_new_dispatchers",
19651 "actorNewDispatchers",
19652 "actor_cdc_table_snapshot_splits",
19653 "actorCdcTableSnapshotSplits",
19654 "sink_schema_change",
19655 "sinkSchemaChange",
19656 "subscriptions_to_drop",
19657 "subscriptionsToDrop",
19658 "iceberg_pk_index_compaction",
19659 "icebergPkIndexCompaction",
19660 ];
19661
19662 #[allow(clippy::enum_variant_names)]
19663 enum GeneratedField {
19664 DispatcherUpdate,
19665 MergeUpdate,
19666 ActorVnodeBitmapUpdate,
19667 DroppedActors,
19668 ActorSplits,
19669 ActorNewDispatchers,
19670 ActorCdcTableSnapshotSplits,
19671 SinkSchemaChange,
19672 SubscriptionsToDrop,
19673 IcebergPkIndexCompaction,
19674 }
19675 impl<'de> serde::Deserialize<'de> for GeneratedField {
19676 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19677 where
19678 D: serde::Deserializer<'de>,
19679 {
19680 struct GeneratedVisitor;
19681
19682 impl serde::de::Visitor<'_> for GeneratedVisitor {
19683 type Value = GeneratedField;
19684
19685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19686 write!(formatter, "expected one of: {:?}", &FIELDS)
19687 }
19688
19689 #[allow(unused_variables)]
19690 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19691 where
19692 E: serde::de::Error,
19693 {
19694 match value {
19695 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
19696 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
19697 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
19698 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
19699 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
19700 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
19701 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
19702 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
19703 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
19704 "icebergPkIndexCompaction" | "iceberg_pk_index_compaction" => Ok(GeneratedField::IcebergPkIndexCompaction),
19705 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19706 }
19707 }
19708 }
19709 deserializer.deserialize_identifier(GeneratedVisitor)
19710 }
19711 }
19712 struct GeneratedVisitor;
19713 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19714 type Value = UpdateMutation;
19715
19716 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19717 formatter.write_str("struct stream_plan.UpdateMutation")
19718 }
19719
19720 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
19721 where
19722 V: serde::de::MapAccess<'de>,
19723 {
19724 let mut dispatcher_update__ = None;
19725 let mut merge_update__ = None;
19726 let mut actor_vnode_bitmap_update__ = None;
19727 let mut dropped_actors__ = None;
19728 let mut actor_splits__ = None;
19729 let mut actor_new_dispatchers__ = None;
19730 let mut actor_cdc_table_snapshot_splits__ = None;
19731 let mut sink_schema_change__ = None;
19732 let mut subscriptions_to_drop__ = None;
19733 let mut iceberg_pk_index_compaction__ = None;
19734 while let Some(k) = map_.next_key()? {
19735 match k {
19736 GeneratedField::DispatcherUpdate => {
19737 if dispatcher_update__.is_some() {
19738 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
19739 }
19740 dispatcher_update__ = Some(map_.next_value()?);
19741 }
19742 GeneratedField::MergeUpdate => {
19743 if merge_update__.is_some() {
19744 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
19745 }
19746 merge_update__ = Some(map_.next_value()?);
19747 }
19748 GeneratedField::ActorVnodeBitmapUpdate => {
19749 if actor_vnode_bitmap_update__.is_some() {
19750 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
19751 }
19752 actor_vnode_bitmap_update__ = Some(
19753 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19754 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19755 );
19756 }
19757 GeneratedField::DroppedActors => {
19758 if dropped_actors__.is_some() {
19759 return Err(serde::de::Error::duplicate_field("droppedActors"));
19760 }
19761 dropped_actors__ =
19762 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19763 .into_iter().map(|x| x.0).collect())
19764 ;
19765 }
19766 GeneratedField::ActorSplits => {
19767 if actor_splits__.is_some() {
19768 return Err(serde::de::Error::duplicate_field("actorSplits"));
19769 }
19770 actor_splits__ = Some(
19771 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19772 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19773 );
19774 }
19775 GeneratedField::ActorNewDispatchers => {
19776 if actor_new_dispatchers__.is_some() {
19777 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
19778 }
19779 actor_new_dispatchers__ = Some(
19780 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19781 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19782 );
19783 }
19784 GeneratedField::ActorCdcTableSnapshotSplits => {
19785 if actor_cdc_table_snapshot_splits__.is_some() {
19786 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
19787 }
19788 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
19789 }
19790 GeneratedField::SinkSchemaChange => {
19791 if sink_schema_change__.is_some() {
19792 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
19793 }
19794 sink_schema_change__ = Some(
19795 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19796 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19797 );
19798 }
19799 GeneratedField::SubscriptionsToDrop => {
19800 if subscriptions_to_drop__.is_some() {
19801 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
19802 }
19803 subscriptions_to_drop__ = Some(map_.next_value()?);
19804 }
19805 GeneratedField::IcebergPkIndexCompaction => {
19806 if iceberg_pk_index_compaction__.is_some() {
19807 return Err(serde::de::Error::duplicate_field("icebergPkIndexCompaction"));
19808 }
19809 iceberg_pk_index_compaction__ = map_.next_value()?;
19810 }
19811 }
19812 }
19813 Ok(UpdateMutation {
19814 dispatcher_update: dispatcher_update__.unwrap_or_default(),
19815 merge_update: merge_update__.unwrap_or_default(),
19816 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
19817 dropped_actors: dropped_actors__.unwrap_or_default(),
19818 actor_splits: actor_splits__.unwrap_or_default(),
19819 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
19820 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
19821 sink_schema_change: sink_schema_change__.unwrap_or_default(),
19822 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
19823 iceberg_pk_index_compaction: iceberg_pk_index_compaction__,
19824 })
19825 }
19826 }
19827 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
19828 }
19829}
19830impl serde::Serialize for update_mutation::DispatcherUpdate {
19831 #[allow(deprecated)]
19832 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19833 where
19834 S: serde::Serializer,
19835 {
19836 use serde::ser::SerializeStruct;
19837 let mut len = 0;
19838 if self.actor_id != 0 {
19839 len += 1;
19840 }
19841 if self.dispatcher_id != 0 {
19842 len += 1;
19843 }
19844 if self.hash_mapping.is_some() {
19845 len += 1;
19846 }
19847 if !self.added_downstream_actor_id.is_empty() {
19848 len += 1;
19849 }
19850 if !self.removed_downstream_actor_id.is_empty() {
19851 len += 1;
19852 }
19853 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
19854 if self.actor_id != 0 {
19855 struct_ser.serialize_field("actorId", &self.actor_id)?;
19856 }
19857 if self.dispatcher_id != 0 {
19858 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
19859 }
19860 if let Some(v) = self.hash_mapping.as_ref() {
19861 struct_ser.serialize_field("hashMapping", v)?;
19862 }
19863 if !self.added_downstream_actor_id.is_empty() {
19864 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
19865 }
19866 if !self.removed_downstream_actor_id.is_empty() {
19867 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
19868 }
19869 struct_ser.end()
19870 }
19871}
19872impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
19873 #[allow(deprecated)]
19874 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19875 where
19876 D: serde::Deserializer<'de>,
19877 {
19878 const FIELDS: &[&str] = &[
19879 "actor_id",
19880 "actorId",
19881 "dispatcher_id",
19882 "dispatcherId",
19883 "hash_mapping",
19884 "hashMapping",
19885 "added_downstream_actor_id",
19886 "addedDownstreamActorId",
19887 "removed_downstream_actor_id",
19888 "removedDownstreamActorId",
19889 ];
19890
19891 #[allow(clippy::enum_variant_names)]
19892 enum GeneratedField {
19893 ActorId,
19894 DispatcherId,
19895 HashMapping,
19896 AddedDownstreamActorId,
19897 RemovedDownstreamActorId,
19898 }
19899 impl<'de> serde::Deserialize<'de> for GeneratedField {
19900 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19901 where
19902 D: serde::Deserializer<'de>,
19903 {
19904 struct GeneratedVisitor;
19905
19906 impl serde::de::Visitor<'_> for GeneratedVisitor {
19907 type Value = GeneratedField;
19908
19909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19910 write!(formatter, "expected one of: {:?}", &FIELDS)
19911 }
19912
19913 #[allow(unused_variables)]
19914 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19915 where
19916 E: serde::de::Error,
19917 {
19918 match value {
19919 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
19920 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
19921 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
19922 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
19923 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
19924 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19925 }
19926 }
19927 }
19928 deserializer.deserialize_identifier(GeneratedVisitor)
19929 }
19930 }
19931 struct GeneratedVisitor;
19932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19933 type Value = update_mutation::DispatcherUpdate;
19934
19935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19936 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
19937 }
19938
19939 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
19940 where
19941 V: serde::de::MapAccess<'de>,
19942 {
19943 let mut actor_id__ = None;
19944 let mut dispatcher_id__ = None;
19945 let mut hash_mapping__ = None;
19946 let mut added_downstream_actor_id__ = None;
19947 let mut removed_downstream_actor_id__ = None;
19948 while let Some(k) = map_.next_key()? {
19949 match k {
19950 GeneratedField::ActorId => {
19951 if actor_id__.is_some() {
19952 return Err(serde::de::Error::duplicate_field("actorId"));
19953 }
19954 actor_id__ =
19955 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19956 ;
19957 }
19958 GeneratedField::DispatcherId => {
19959 if dispatcher_id__.is_some() {
19960 return Err(serde::de::Error::duplicate_field("dispatcherId"));
19961 }
19962 dispatcher_id__ =
19963 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19964 ;
19965 }
19966 GeneratedField::HashMapping => {
19967 if hash_mapping__.is_some() {
19968 return Err(serde::de::Error::duplicate_field("hashMapping"));
19969 }
19970 hash_mapping__ = map_.next_value()?;
19971 }
19972 GeneratedField::AddedDownstreamActorId => {
19973 if added_downstream_actor_id__.is_some() {
19974 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
19975 }
19976 added_downstream_actor_id__ =
19977 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19978 .into_iter().map(|x| x.0).collect())
19979 ;
19980 }
19981 GeneratedField::RemovedDownstreamActorId => {
19982 if removed_downstream_actor_id__.is_some() {
19983 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
19984 }
19985 removed_downstream_actor_id__ =
19986 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19987 .into_iter().map(|x| x.0).collect())
19988 ;
19989 }
19990 }
19991 }
19992 Ok(update_mutation::DispatcherUpdate {
19993 actor_id: actor_id__.unwrap_or_default(),
19994 dispatcher_id: dispatcher_id__.unwrap_or_default(),
19995 hash_mapping: hash_mapping__,
19996 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
19997 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
19998 })
19999 }
20000 }
20001 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
20002 }
20003}
20004impl serde::Serialize for update_mutation::MergeUpdate {
20005 #[allow(deprecated)]
20006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20007 where
20008 S: serde::Serializer,
20009 {
20010 use serde::ser::SerializeStruct;
20011 let mut len = 0;
20012 if self.actor_id != 0 {
20013 len += 1;
20014 }
20015 if self.upstream_fragment_id != 0 {
20016 len += 1;
20017 }
20018 if self.new_upstream_fragment_id.is_some() {
20019 len += 1;
20020 }
20021 if !self.added_upstream_actors.is_empty() {
20022 len += 1;
20023 }
20024 if !self.removed_upstream_actor_id.is_empty() {
20025 len += 1;
20026 }
20027 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
20028 if self.actor_id != 0 {
20029 struct_ser.serialize_field("actorId", &self.actor_id)?;
20030 }
20031 if self.upstream_fragment_id != 0 {
20032 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
20033 }
20034 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
20035 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
20036 }
20037 if !self.added_upstream_actors.is_empty() {
20038 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
20039 }
20040 if !self.removed_upstream_actor_id.is_empty() {
20041 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
20042 }
20043 struct_ser.end()
20044 }
20045}
20046impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
20047 #[allow(deprecated)]
20048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20049 where
20050 D: serde::Deserializer<'de>,
20051 {
20052 const FIELDS: &[&str] = &[
20053 "actor_id",
20054 "actorId",
20055 "upstream_fragment_id",
20056 "upstreamFragmentId",
20057 "new_upstream_fragment_id",
20058 "newUpstreamFragmentId",
20059 "added_upstream_actors",
20060 "addedUpstreamActors",
20061 "removed_upstream_actor_id",
20062 "removedUpstreamActorId",
20063 ];
20064
20065 #[allow(clippy::enum_variant_names)]
20066 enum GeneratedField {
20067 ActorId,
20068 UpstreamFragmentId,
20069 NewUpstreamFragmentId,
20070 AddedUpstreamActors,
20071 RemovedUpstreamActorId,
20072 }
20073 impl<'de> serde::Deserialize<'de> for GeneratedField {
20074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20075 where
20076 D: serde::Deserializer<'de>,
20077 {
20078 struct GeneratedVisitor;
20079
20080 impl serde::de::Visitor<'_> for GeneratedVisitor {
20081 type Value = GeneratedField;
20082
20083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20084 write!(formatter, "expected one of: {:?}", &FIELDS)
20085 }
20086
20087 #[allow(unused_variables)]
20088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20089 where
20090 E: serde::de::Error,
20091 {
20092 match value {
20093 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
20094 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
20095 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
20096 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
20097 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
20098 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20099 }
20100 }
20101 }
20102 deserializer.deserialize_identifier(GeneratedVisitor)
20103 }
20104 }
20105 struct GeneratedVisitor;
20106 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20107 type Value = update_mutation::MergeUpdate;
20108
20109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20110 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
20111 }
20112
20113 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
20114 where
20115 V: serde::de::MapAccess<'de>,
20116 {
20117 let mut actor_id__ = None;
20118 let mut upstream_fragment_id__ = None;
20119 let mut new_upstream_fragment_id__ = None;
20120 let mut added_upstream_actors__ = None;
20121 let mut removed_upstream_actor_id__ = None;
20122 while let Some(k) = map_.next_key()? {
20123 match k {
20124 GeneratedField::ActorId => {
20125 if actor_id__.is_some() {
20126 return Err(serde::de::Error::duplicate_field("actorId"));
20127 }
20128 actor_id__ =
20129 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20130 ;
20131 }
20132 GeneratedField::UpstreamFragmentId => {
20133 if upstream_fragment_id__.is_some() {
20134 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
20135 }
20136 upstream_fragment_id__ =
20137 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20138 ;
20139 }
20140 GeneratedField::NewUpstreamFragmentId => {
20141 if new_upstream_fragment_id__.is_some() {
20142 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
20143 }
20144 new_upstream_fragment_id__ =
20145 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
20146 ;
20147 }
20148 GeneratedField::AddedUpstreamActors => {
20149 if added_upstream_actors__.is_some() {
20150 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
20151 }
20152 added_upstream_actors__ = Some(map_.next_value()?);
20153 }
20154 GeneratedField::RemovedUpstreamActorId => {
20155 if removed_upstream_actor_id__.is_some() {
20156 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
20157 }
20158 removed_upstream_actor_id__ =
20159 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20160 .into_iter().map(|x| x.0).collect())
20161 ;
20162 }
20163 }
20164 }
20165 Ok(update_mutation::MergeUpdate {
20166 actor_id: actor_id__.unwrap_or_default(),
20167 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
20168 new_upstream_fragment_id: new_upstream_fragment_id__,
20169 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
20170 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
20171 })
20172 }
20173 }
20174 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
20175 }
20176}
20177impl serde::Serialize for UpstreamSinkInfo {
20178 #[allow(deprecated)]
20179 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20180 where
20181 S: serde::Serializer,
20182 {
20183 use serde::ser::SerializeStruct;
20184 let mut len = 0;
20185 if self.upstream_fragment_id != 0 {
20186 len += 1;
20187 }
20188 if !self.sink_output_schema.is_empty() {
20189 len += 1;
20190 }
20191 if !self.project_exprs.is_empty() {
20192 len += 1;
20193 }
20194 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
20195 if self.upstream_fragment_id != 0 {
20196 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
20197 }
20198 if !self.sink_output_schema.is_empty() {
20199 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
20200 }
20201 if !self.project_exprs.is_empty() {
20202 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
20203 }
20204 struct_ser.end()
20205 }
20206}
20207impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
20208 #[allow(deprecated)]
20209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20210 where
20211 D: serde::Deserializer<'de>,
20212 {
20213 const FIELDS: &[&str] = &[
20214 "upstream_fragment_id",
20215 "upstreamFragmentId",
20216 "sink_output_schema",
20217 "sinkOutputSchema",
20218 "project_exprs",
20219 "projectExprs",
20220 ];
20221
20222 #[allow(clippy::enum_variant_names)]
20223 enum GeneratedField {
20224 UpstreamFragmentId,
20225 SinkOutputSchema,
20226 ProjectExprs,
20227 }
20228 impl<'de> serde::Deserialize<'de> for GeneratedField {
20229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20230 where
20231 D: serde::Deserializer<'de>,
20232 {
20233 struct GeneratedVisitor;
20234
20235 impl serde::de::Visitor<'_> for GeneratedVisitor {
20236 type Value = GeneratedField;
20237
20238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20239 write!(formatter, "expected one of: {:?}", &FIELDS)
20240 }
20241
20242 #[allow(unused_variables)]
20243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20244 where
20245 E: serde::de::Error,
20246 {
20247 match value {
20248 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
20249 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
20250 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
20251 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20252 }
20253 }
20254 }
20255 deserializer.deserialize_identifier(GeneratedVisitor)
20256 }
20257 }
20258 struct GeneratedVisitor;
20259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20260 type Value = UpstreamSinkInfo;
20261
20262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20263 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
20264 }
20265
20266 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
20267 where
20268 V: serde::de::MapAccess<'de>,
20269 {
20270 let mut upstream_fragment_id__ = None;
20271 let mut sink_output_schema__ = None;
20272 let mut project_exprs__ = None;
20273 while let Some(k) = map_.next_key()? {
20274 match k {
20275 GeneratedField::UpstreamFragmentId => {
20276 if upstream_fragment_id__.is_some() {
20277 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
20278 }
20279 upstream_fragment_id__ =
20280 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20281 ;
20282 }
20283 GeneratedField::SinkOutputSchema => {
20284 if sink_output_schema__.is_some() {
20285 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
20286 }
20287 sink_output_schema__ = Some(map_.next_value()?);
20288 }
20289 GeneratedField::ProjectExprs => {
20290 if project_exprs__.is_some() {
20291 return Err(serde::de::Error::duplicate_field("projectExprs"));
20292 }
20293 project_exprs__ = Some(map_.next_value()?);
20294 }
20295 }
20296 }
20297 Ok(UpstreamSinkInfo {
20298 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
20299 sink_output_schema: sink_output_schema__.unwrap_or_default(),
20300 project_exprs: project_exprs__.unwrap_or_default(),
20301 })
20302 }
20303 }
20304 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
20305 }
20306}
20307impl serde::Serialize for UpstreamSinkUnionNode {
20308 #[allow(deprecated)]
20309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20310 where
20311 S: serde::Serializer,
20312 {
20313 use serde::ser::SerializeStruct;
20314 let mut len = 0;
20315 if !self.init_upstreams.is_empty() {
20316 len += 1;
20317 }
20318 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
20319 if !self.init_upstreams.is_empty() {
20320 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
20321 }
20322 struct_ser.end()
20323 }
20324}
20325impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
20326 #[allow(deprecated)]
20327 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20328 where
20329 D: serde::Deserializer<'de>,
20330 {
20331 const FIELDS: &[&str] = &[
20332 "init_upstreams",
20333 "initUpstreams",
20334 ];
20335
20336 #[allow(clippy::enum_variant_names)]
20337 enum GeneratedField {
20338 InitUpstreams,
20339 }
20340 impl<'de> serde::Deserialize<'de> for GeneratedField {
20341 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20342 where
20343 D: serde::Deserializer<'de>,
20344 {
20345 struct GeneratedVisitor;
20346
20347 impl serde::de::Visitor<'_> for GeneratedVisitor {
20348 type Value = GeneratedField;
20349
20350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20351 write!(formatter, "expected one of: {:?}", &FIELDS)
20352 }
20353
20354 #[allow(unused_variables)]
20355 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20356 where
20357 E: serde::de::Error,
20358 {
20359 match value {
20360 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
20361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20362 }
20363 }
20364 }
20365 deserializer.deserialize_identifier(GeneratedVisitor)
20366 }
20367 }
20368 struct GeneratedVisitor;
20369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20370 type Value = UpstreamSinkUnionNode;
20371
20372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20373 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
20374 }
20375
20376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
20377 where
20378 V: serde::de::MapAccess<'de>,
20379 {
20380 let mut init_upstreams__ = None;
20381 while let Some(k) = map_.next_key()? {
20382 match k {
20383 GeneratedField::InitUpstreams => {
20384 if init_upstreams__.is_some() {
20385 return Err(serde::de::Error::duplicate_field("initUpstreams"));
20386 }
20387 init_upstreams__ = Some(map_.next_value()?);
20388 }
20389 }
20390 }
20391 Ok(UpstreamSinkUnionNode {
20392 init_upstreams: init_upstreams__.unwrap_or_default(),
20393 })
20394 }
20395 }
20396 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
20397 }
20398}
20399impl serde::Serialize for ValuesNode {
20400 #[allow(deprecated)]
20401 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20402 where
20403 S: serde::Serializer,
20404 {
20405 use serde::ser::SerializeStruct;
20406 let mut len = 0;
20407 if !self.tuples.is_empty() {
20408 len += 1;
20409 }
20410 if !self.fields.is_empty() {
20411 len += 1;
20412 }
20413 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
20414 if !self.tuples.is_empty() {
20415 struct_ser.serialize_field("tuples", &self.tuples)?;
20416 }
20417 if !self.fields.is_empty() {
20418 struct_ser.serialize_field("fields", &self.fields)?;
20419 }
20420 struct_ser.end()
20421 }
20422}
20423impl<'de> serde::Deserialize<'de> for ValuesNode {
20424 #[allow(deprecated)]
20425 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20426 where
20427 D: serde::Deserializer<'de>,
20428 {
20429 const FIELDS: &[&str] = &[
20430 "tuples",
20431 "fields",
20432 ];
20433
20434 #[allow(clippy::enum_variant_names)]
20435 enum GeneratedField {
20436 Tuples,
20437 Fields,
20438 }
20439 impl<'de> serde::Deserialize<'de> for GeneratedField {
20440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20441 where
20442 D: serde::Deserializer<'de>,
20443 {
20444 struct GeneratedVisitor;
20445
20446 impl serde::de::Visitor<'_> for GeneratedVisitor {
20447 type Value = GeneratedField;
20448
20449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20450 write!(formatter, "expected one of: {:?}", &FIELDS)
20451 }
20452
20453 #[allow(unused_variables)]
20454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20455 where
20456 E: serde::de::Error,
20457 {
20458 match value {
20459 "tuples" => Ok(GeneratedField::Tuples),
20460 "fields" => Ok(GeneratedField::Fields),
20461 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20462 }
20463 }
20464 }
20465 deserializer.deserialize_identifier(GeneratedVisitor)
20466 }
20467 }
20468 struct GeneratedVisitor;
20469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20470 type Value = ValuesNode;
20471
20472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20473 formatter.write_str("struct stream_plan.ValuesNode")
20474 }
20475
20476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
20477 where
20478 V: serde::de::MapAccess<'de>,
20479 {
20480 let mut tuples__ = None;
20481 let mut fields__ = None;
20482 while let Some(k) = map_.next_key()? {
20483 match k {
20484 GeneratedField::Tuples => {
20485 if tuples__.is_some() {
20486 return Err(serde::de::Error::duplicate_field("tuples"));
20487 }
20488 tuples__ = Some(map_.next_value()?);
20489 }
20490 GeneratedField::Fields => {
20491 if fields__.is_some() {
20492 return Err(serde::de::Error::duplicate_field("fields"));
20493 }
20494 fields__ = Some(map_.next_value()?);
20495 }
20496 }
20497 }
20498 Ok(ValuesNode {
20499 tuples: tuples__.unwrap_or_default(),
20500 fields: fields__.unwrap_or_default(),
20501 })
20502 }
20503 }
20504 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
20505 }
20506}
20507impl serde::Serialize for values_node::ExprTuple {
20508 #[allow(deprecated)]
20509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20510 where
20511 S: serde::Serializer,
20512 {
20513 use serde::ser::SerializeStruct;
20514 let mut len = 0;
20515 if !self.cells.is_empty() {
20516 len += 1;
20517 }
20518 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
20519 if !self.cells.is_empty() {
20520 struct_ser.serialize_field("cells", &self.cells)?;
20521 }
20522 struct_ser.end()
20523 }
20524}
20525impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
20526 #[allow(deprecated)]
20527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20528 where
20529 D: serde::Deserializer<'de>,
20530 {
20531 const FIELDS: &[&str] = &[
20532 "cells",
20533 ];
20534
20535 #[allow(clippy::enum_variant_names)]
20536 enum GeneratedField {
20537 Cells,
20538 }
20539 impl<'de> serde::Deserialize<'de> for GeneratedField {
20540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20541 where
20542 D: serde::Deserializer<'de>,
20543 {
20544 struct GeneratedVisitor;
20545
20546 impl serde::de::Visitor<'_> for GeneratedVisitor {
20547 type Value = GeneratedField;
20548
20549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20550 write!(formatter, "expected one of: {:?}", &FIELDS)
20551 }
20552
20553 #[allow(unused_variables)]
20554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20555 where
20556 E: serde::de::Error,
20557 {
20558 match value {
20559 "cells" => Ok(GeneratedField::Cells),
20560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20561 }
20562 }
20563 }
20564 deserializer.deserialize_identifier(GeneratedVisitor)
20565 }
20566 }
20567 struct GeneratedVisitor;
20568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20569 type Value = values_node::ExprTuple;
20570
20571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20572 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
20573 }
20574
20575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
20576 where
20577 V: serde::de::MapAccess<'de>,
20578 {
20579 let mut cells__ = None;
20580 while let Some(k) = map_.next_key()? {
20581 match k {
20582 GeneratedField::Cells => {
20583 if cells__.is_some() {
20584 return Err(serde::de::Error::duplicate_field("cells"));
20585 }
20586 cells__ = Some(map_.next_value()?);
20587 }
20588 }
20589 }
20590 Ok(values_node::ExprTuple {
20591 cells: cells__.unwrap_or_default(),
20592 })
20593 }
20594 }
20595 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
20596 }
20597}
20598impl serde::Serialize for VectorIndexLookupJoinNode {
20599 #[allow(deprecated)]
20600 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20601 where
20602 S: serde::Serializer,
20603 {
20604 use serde::ser::SerializeStruct;
20605 let mut len = 0;
20606 if self.reader_desc.is_some() {
20607 len += 1;
20608 }
20609 if self.vector_column_idx != 0 {
20610 len += 1;
20611 }
20612 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
20613 if let Some(v) = self.reader_desc.as_ref() {
20614 struct_ser.serialize_field("readerDesc", v)?;
20615 }
20616 if self.vector_column_idx != 0 {
20617 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
20618 }
20619 struct_ser.end()
20620 }
20621}
20622impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
20623 #[allow(deprecated)]
20624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20625 where
20626 D: serde::Deserializer<'de>,
20627 {
20628 const FIELDS: &[&str] = &[
20629 "reader_desc",
20630 "readerDesc",
20631 "vector_column_idx",
20632 "vectorColumnIdx",
20633 ];
20634
20635 #[allow(clippy::enum_variant_names)]
20636 enum GeneratedField {
20637 ReaderDesc,
20638 VectorColumnIdx,
20639 }
20640 impl<'de> serde::Deserialize<'de> for GeneratedField {
20641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20642 where
20643 D: serde::Deserializer<'de>,
20644 {
20645 struct GeneratedVisitor;
20646
20647 impl serde::de::Visitor<'_> for GeneratedVisitor {
20648 type Value = GeneratedField;
20649
20650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20651 write!(formatter, "expected one of: {:?}", &FIELDS)
20652 }
20653
20654 #[allow(unused_variables)]
20655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20656 where
20657 E: serde::de::Error,
20658 {
20659 match value {
20660 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
20661 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
20662 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20663 }
20664 }
20665 }
20666 deserializer.deserialize_identifier(GeneratedVisitor)
20667 }
20668 }
20669 struct GeneratedVisitor;
20670 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20671 type Value = VectorIndexLookupJoinNode;
20672
20673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20674 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
20675 }
20676
20677 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
20678 where
20679 V: serde::de::MapAccess<'de>,
20680 {
20681 let mut reader_desc__ = None;
20682 let mut vector_column_idx__ = None;
20683 while let Some(k) = map_.next_key()? {
20684 match k {
20685 GeneratedField::ReaderDesc => {
20686 if reader_desc__.is_some() {
20687 return Err(serde::de::Error::duplicate_field("readerDesc"));
20688 }
20689 reader_desc__ = map_.next_value()?;
20690 }
20691 GeneratedField::VectorColumnIdx => {
20692 if vector_column_idx__.is_some() {
20693 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
20694 }
20695 vector_column_idx__ =
20696 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20697 ;
20698 }
20699 }
20700 }
20701 Ok(VectorIndexLookupJoinNode {
20702 reader_desc: reader_desc__,
20703 vector_column_idx: vector_column_idx__.unwrap_or_default(),
20704 })
20705 }
20706 }
20707 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
20708 }
20709}
20710impl serde::Serialize for VectorIndexWriteNode {
20711 #[allow(deprecated)]
20712 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20713 where
20714 S: serde::Serializer,
20715 {
20716 use serde::ser::SerializeStruct;
20717 let mut len = 0;
20718 if self.table.is_some() {
20719 len += 1;
20720 }
20721 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
20722 if let Some(v) = self.table.as_ref() {
20723 struct_ser.serialize_field("table", v)?;
20724 }
20725 struct_ser.end()
20726 }
20727}
20728impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
20729 #[allow(deprecated)]
20730 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20731 where
20732 D: serde::Deserializer<'de>,
20733 {
20734 const FIELDS: &[&str] = &[
20735 "table",
20736 ];
20737
20738 #[allow(clippy::enum_variant_names)]
20739 enum GeneratedField {
20740 Table,
20741 }
20742 impl<'de> serde::Deserialize<'de> for GeneratedField {
20743 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20744 where
20745 D: serde::Deserializer<'de>,
20746 {
20747 struct GeneratedVisitor;
20748
20749 impl serde::de::Visitor<'_> for GeneratedVisitor {
20750 type Value = GeneratedField;
20751
20752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20753 write!(formatter, "expected one of: {:?}", &FIELDS)
20754 }
20755
20756 #[allow(unused_variables)]
20757 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20758 where
20759 E: serde::de::Error,
20760 {
20761 match value {
20762 "table" => Ok(GeneratedField::Table),
20763 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20764 }
20765 }
20766 }
20767 deserializer.deserialize_identifier(GeneratedVisitor)
20768 }
20769 }
20770 struct GeneratedVisitor;
20771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20772 type Value = VectorIndexWriteNode;
20773
20774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20775 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
20776 }
20777
20778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
20779 where
20780 V: serde::de::MapAccess<'de>,
20781 {
20782 let mut table__ = None;
20783 while let Some(k) = map_.next_key()? {
20784 match k {
20785 GeneratedField::Table => {
20786 if table__.is_some() {
20787 return Err(serde::de::Error::duplicate_field("table"));
20788 }
20789 table__ = map_.next_value()?;
20790 }
20791 }
20792 }
20793 Ok(VectorIndexWriteNode {
20794 table: table__,
20795 })
20796 }
20797 }
20798 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
20799 }
20800}
20801impl serde::Serialize for Watermark {
20802 #[allow(deprecated)]
20803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20804 where
20805 S: serde::Serializer,
20806 {
20807 use serde::ser::SerializeStruct;
20808 let mut len = 0;
20809 if self.column.is_some() {
20810 len += 1;
20811 }
20812 if self.val.is_some() {
20813 len += 1;
20814 }
20815 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
20816 if let Some(v) = self.column.as_ref() {
20817 struct_ser.serialize_field("column", v)?;
20818 }
20819 if let Some(v) = self.val.as_ref() {
20820 struct_ser.serialize_field("val", v)?;
20821 }
20822 struct_ser.end()
20823 }
20824}
20825impl<'de> serde::Deserialize<'de> for Watermark {
20826 #[allow(deprecated)]
20827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20828 where
20829 D: serde::Deserializer<'de>,
20830 {
20831 const FIELDS: &[&str] = &[
20832 "column",
20833 "val",
20834 ];
20835
20836 #[allow(clippy::enum_variant_names)]
20837 enum GeneratedField {
20838 Column,
20839 Val,
20840 }
20841 impl<'de> serde::Deserialize<'de> for GeneratedField {
20842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20843 where
20844 D: serde::Deserializer<'de>,
20845 {
20846 struct GeneratedVisitor;
20847
20848 impl serde::de::Visitor<'_> for GeneratedVisitor {
20849 type Value = GeneratedField;
20850
20851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20852 write!(formatter, "expected one of: {:?}", &FIELDS)
20853 }
20854
20855 #[allow(unused_variables)]
20856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20857 where
20858 E: serde::de::Error,
20859 {
20860 match value {
20861 "column" => Ok(GeneratedField::Column),
20862 "val" => Ok(GeneratedField::Val),
20863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20864 }
20865 }
20866 }
20867 deserializer.deserialize_identifier(GeneratedVisitor)
20868 }
20869 }
20870 struct GeneratedVisitor;
20871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20872 type Value = Watermark;
20873
20874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20875 formatter.write_str("struct stream_plan.Watermark")
20876 }
20877
20878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
20879 where
20880 V: serde::de::MapAccess<'de>,
20881 {
20882 let mut column__ = None;
20883 let mut val__ = None;
20884 while let Some(k) = map_.next_key()? {
20885 match k {
20886 GeneratedField::Column => {
20887 if column__.is_some() {
20888 return Err(serde::de::Error::duplicate_field("column"));
20889 }
20890 column__ = map_.next_value()?;
20891 }
20892 GeneratedField::Val => {
20893 if val__.is_some() {
20894 return Err(serde::de::Error::duplicate_field("val"));
20895 }
20896 val__ = map_.next_value()?;
20897 }
20898 }
20899 }
20900 Ok(Watermark {
20901 column: column__,
20902 val: val__,
20903 })
20904 }
20905 }
20906 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
20907 }
20908}
20909impl serde::Serialize for WatermarkFilterNode {
20910 #[allow(deprecated)]
20911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20912 where
20913 S: serde::Serializer,
20914 {
20915 use serde::ser::SerializeStruct;
20916 let mut len = 0;
20917 if !self.watermark_descs.is_empty() {
20918 len += 1;
20919 }
20920 if !self.tables.is_empty() {
20921 len += 1;
20922 }
20923 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
20924 if !self.watermark_descs.is_empty() {
20925 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
20926 }
20927 if !self.tables.is_empty() {
20928 struct_ser.serialize_field("tables", &self.tables)?;
20929 }
20930 struct_ser.end()
20931 }
20932}
20933impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
20934 #[allow(deprecated)]
20935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20936 where
20937 D: serde::Deserializer<'de>,
20938 {
20939 const FIELDS: &[&str] = &[
20940 "watermark_descs",
20941 "watermarkDescs",
20942 "tables",
20943 ];
20944
20945 #[allow(clippy::enum_variant_names)]
20946 enum GeneratedField {
20947 WatermarkDescs,
20948 Tables,
20949 }
20950 impl<'de> serde::Deserialize<'de> for GeneratedField {
20951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20952 where
20953 D: serde::Deserializer<'de>,
20954 {
20955 struct GeneratedVisitor;
20956
20957 impl serde::de::Visitor<'_> for GeneratedVisitor {
20958 type Value = GeneratedField;
20959
20960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20961 write!(formatter, "expected one of: {:?}", &FIELDS)
20962 }
20963
20964 #[allow(unused_variables)]
20965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20966 where
20967 E: serde::de::Error,
20968 {
20969 match value {
20970 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
20971 "tables" => Ok(GeneratedField::Tables),
20972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20973 }
20974 }
20975 }
20976 deserializer.deserialize_identifier(GeneratedVisitor)
20977 }
20978 }
20979 struct GeneratedVisitor;
20980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20981 type Value = WatermarkFilterNode;
20982
20983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20984 formatter.write_str("struct stream_plan.WatermarkFilterNode")
20985 }
20986
20987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
20988 where
20989 V: serde::de::MapAccess<'de>,
20990 {
20991 let mut watermark_descs__ = None;
20992 let mut tables__ = None;
20993 while let Some(k) = map_.next_key()? {
20994 match k {
20995 GeneratedField::WatermarkDescs => {
20996 if watermark_descs__.is_some() {
20997 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
20998 }
20999 watermark_descs__ = Some(map_.next_value()?);
21000 }
21001 GeneratedField::Tables => {
21002 if tables__.is_some() {
21003 return Err(serde::de::Error::duplicate_field("tables"));
21004 }
21005 tables__ = Some(map_.next_value()?);
21006 }
21007 }
21008 }
21009 Ok(WatermarkFilterNode {
21010 watermark_descs: watermark_descs__.unwrap_or_default(),
21011 tables: tables__.unwrap_or_default(),
21012 })
21013 }
21014 }
21015 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
21016 }
21017}