1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::stream_plan::*;
4impl serde::Serialize for ActorMapping {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if !self.original_indices.is_empty() {
13 len += 1;
14 }
15 if !self.data.is_empty() {
16 len += 1;
17 }
18 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
19 if !self.original_indices.is_empty() {
20 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
21 }
22 if !self.data.is_empty() {
23 struct_ser.serialize_field("data", &self.data)?;
24 }
25 struct_ser.end()
26 }
27}
28impl<'de> serde::Deserialize<'de> for ActorMapping {
29 #[allow(deprecated)]
30 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
31 where
32 D: serde::Deserializer<'de>,
33 {
34 const FIELDS: &[&str] = &[
35 "original_indices",
36 "originalIndices",
37 "data",
38 ];
39
40 #[allow(clippy::enum_variant_names)]
41 enum GeneratedField {
42 OriginalIndices,
43 Data,
44 }
45 impl<'de> serde::Deserialize<'de> for GeneratedField {
46 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
47 where
48 D: serde::Deserializer<'de>,
49 {
50 struct GeneratedVisitor;
51
52 impl serde::de::Visitor<'_> for GeneratedVisitor {
53 type Value = GeneratedField;
54
55 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 write!(formatter, "expected one of: {:?}", &FIELDS)
57 }
58
59 #[allow(unused_variables)]
60 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
61 where
62 E: serde::de::Error,
63 {
64 match value {
65 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
66 "data" => Ok(GeneratedField::Data),
67 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
68 }
69 }
70 }
71 deserializer.deserialize_identifier(GeneratedVisitor)
72 }
73 }
74 struct GeneratedVisitor;
75 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
76 type Value = ActorMapping;
77
78 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79 formatter.write_str("struct stream_plan.ActorMapping")
80 }
81
82 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
83 where
84 V: serde::de::MapAccess<'de>,
85 {
86 let mut original_indices__ = None;
87 let mut data__ = None;
88 while let Some(k) = map_.next_key()? {
89 match k {
90 GeneratedField::OriginalIndices => {
91 if original_indices__.is_some() {
92 return Err(serde::de::Error::duplicate_field("originalIndices"));
93 }
94 original_indices__ =
95 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
96 .into_iter().map(|x| x.0).collect())
97 ;
98 }
99 GeneratedField::Data => {
100 if data__.is_some() {
101 return Err(serde::de::Error::duplicate_field("data"));
102 }
103 data__ =
104 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
105 .into_iter().map(|x| x.0).collect())
106 ;
107 }
108 }
109 }
110 Ok(ActorMapping {
111 original_indices: original_indices__.unwrap_or_default(),
112 data: data__.unwrap_or_default(),
113 })
114 }
115 }
116 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
117 }
118}
119impl serde::Serialize for AddMutation {
120 #[allow(deprecated)]
121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
122 where
123 S: serde::Serializer,
124 {
125 use serde::ser::SerializeStruct;
126 let mut len = 0;
127 if !self.actor_dispatchers.is_empty() {
128 len += 1;
129 }
130 if !self.added_actors.is_empty() {
131 len += 1;
132 }
133 if !self.actor_splits.is_empty() {
134 len += 1;
135 }
136 if self.pause {
137 len += 1;
138 }
139 if !self.subscriptions_to_add.is_empty() {
140 len += 1;
141 }
142 if !self.backfill_nodes_to_pause.is_empty() {
143 len += 1;
144 }
145 if self.actor_cdc_table_snapshot_splits.is_some() {
146 len += 1;
147 }
148 if !self.new_upstream_sinks.is_empty() {
149 len += 1;
150 }
151 if !self.dropped_actors.is_empty() {
152 len += 1;
153 }
154 if !self.sink_log_store_flush.is_empty() {
155 len += 1;
156 }
157 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
158 if !self.actor_dispatchers.is_empty() {
159 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
160 }
161 if !self.added_actors.is_empty() {
162 struct_ser.serialize_field("addedActors", &self.added_actors)?;
163 }
164 if !self.actor_splits.is_empty() {
165 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
166 }
167 if self.pause {
168 struct_ser.serialize_field("pause", &self.pause)?;
169 }
170 if !self.subscriptions_to_add.is_empty() {
171 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
172 }
173 if !self.backfill_nodes_to_pause.is_empty() {
174 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
175 }
176 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
177 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
178 }
179 if !self.new_upstream_sinks.is_empty() {
180 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
181 }
182 if !self.dropped_actors.is_empty() {
183 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
184 }
185 if !self.sink_log_store_flush.is_empty() {
186 struct_ser.serialize_field("sinkLogStoreFlush", &self.sink_log_store_flush)?;
187 }
188 struct_ser.end()
189 }
190}
191impl<'de> serde::Deserialize<'de> for AddMutation {
192 #[allow(deprecated)]
193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
194 where
195 D: serde::Deserializer<'de>,
196 {
197 const FIELDS: &[&str] = &[
198 "actor_dispatchers",
199 "actorDispatchers",
200 "added_actors",
201 "addedActors",
202 "actor_splits",
203 "actorSplits",
204 "pause",
205 "subscriptions_to_add",
206 "subscriptionsToAdd",
207 "backfill_nodes_to_pause",
208 "backfillNodesToPause",
209 "actor_cdc_table_snapshot_splits",
210 "actorCdcTableSnapshotSplits",
211 "new_upstream_sinks",
212 "newUpstreamSinks",
213 "dropped_actors",
214 "droppedActors",
215 "sink_log_store_flush",
216 "sinkLogStoreFlush",
217 ];
218
219 #[allow(clippy::enum_variant_names)]
220 enum GeneratedField {
221 ActorDispatchers,
222 AddedActors,
223 ActorSplits,
224 Pause,
225 SubscriptionsToAdd,
226 BackfillNodesToPause,
227 ActorCdcTableSnapshotSplits,
228 NewUpstreamSinks,
229 DroppedActors,
230 SinkLogStoreFlush,
231 }
232 impl<'de> serde::Deserialize<'de> for GeneratedField {
233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
234 where
235 D: serde::Deserializer<'de>,
236 {
237 struct GeneratedVisitor;
238
239 impl serde::de::Visitor<'_> for GeneratedVisitor {
240 type Value = GeneratedField;
241
242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
243 write!(formatter, "expected one of: {:?}", &FIELDS)
244 }
245
246 #[allow(unused_variables)]
247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
248 where
249 E: serde::de::Error,
250 {
251 match value {
252 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
253 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
254 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
255 "pause" => Ok(GeneratedField::Pause),
256 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
257 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
258 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
259 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
260 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
261 "sinkLogStoreFlush" | "sink_log_store_flush" => Ok(GeneratedField::SinkLogStoreFlush),
262 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
263 }
264 }
265 }
266 deserializer.deserialize_identifier(GeneratedVisitor)
267 }
268 }
269 struct GeneratedVisitor;
270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
271 type Value = AddMutation;
272
273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
274 formatter.write_str("struct stream_plan.AddMutation")
275 }
276
277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
278 where
279 V: serde::de::MapAccess<'de>,
280 {
281 let mut actor_dispatchers__ = None;
282 let mut added_actors__ = None;
283 let mut actor_splits__ = None;
284 let mut pause__ = None;
285 let mut subscriptions_to_add__ = None;
286 let mut backfill_nodes_to_pause__ = None;
287 let mut actor_cdc_table_snapshot_splits__ = None;
288 let mut new_upstream_sinks__ = None;
289 let mut dropped_actors__ = None;
290 let mut sink_log_store_flush__ = None;
291 while let Some(k) = map_.next_key()? {
292 match k {
293 GeneratedField::ActorDispatchers => {
294 if actor_dispatchers__.is_some() {
295 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
296 }
297 actor_dispatchers__ = Some(
298 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
299 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
300 );
301 }
302 GeneratedField::AddedActors => {
303 if added_actors__.is_some() {
304 return Err(serde::de::Error::duplicate_field("addedActors"));
305 }
306 added_actors__ =
307 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
308 .into_iter().map(|x| x.0).collect())
309 ;
310 }
311 GeneratedField::ActorSplits => {
312 if actor_splits__.is_some() {
313 return Err(serde::de::Error::duplicate_field("actorSplits"));
314 }
315 actor_splits__ = Some(
316 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
317 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
318 );
319 }
320 GeneratedField::Pause => {
321 if pause__.is_some() {
322 return Err(serde::de::Error::duplicate_field("pause"));
323 }
324 pause__ = Some(map_.next_value()?);
325 }
326 GeneratedField::SubscriptionsToAdd => {
327 if subscriptions_to_add__.is_some() {
328 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
329 }
330 subscriptions_to_add__ = Some(map_.next_value()?);
331 }
332 GeneratedField::BackfillNodesToPause => {
333 if backfill_nodes_to_pause__.is_some() {
334 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
335 }
336 backfill_nodes_to_pause__ =
337 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
338 .into_iter().map(|x| x.0).collect())
339 ;
340 }
341 GeneratedField::ActorCdcTableSnapshotSplits => {
342 if actor_cdc_table_snapshot_splits__.is_some() {
343 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
344 }
345 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
346 }
347 GeneratedField::NewUpstreamSinks => {
348 if new_upstream_sinks__.is_some() {
349 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
350 }
351 new_upstream_sinks__ = Some(
352 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
353 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
354 );
355 }
356 GeneratedField::DroppedActors => {
357 if dropped_actors__.is_some() {
358 return Err(serde::de::Error::duplicate_field("droppedActors"));
359 }
360 dropped_actors__ =
361 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
362 .into_iter().map(|x| x.0).collect())
363 ;
364 }
365 GeneratedField::SinkLogStoreFlush => {
366 if sink_log_store_flush__.is_some() {
367 return Err(serde::de::Error::duplicate_field("sinkLogStoreFlush"));
368 }
369 sink_log_store_flush__ =
370 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
371 .into_iter().map(|x| x.0).collect())
372 ;
373 }
374 }
375 }
376 Ok(AddMutation {
377 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
378 added_actors: added_actors__.unwrap_or_default(),
379 actor_splits: actor_splits__.unwrap_or_default(),
380 pause: pause__.unwrap_or_default(),
381 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
382 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
383 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
384 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
385 dropped_actors: dropped_actors__.unwrap_or_default(),
386 sink_log_store_flush: sink_log_store_flush__.unwrap_or_default(),
387 })
388 }
389 }
390 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
391 }
392}
393impl serde::Serialize for add_mutation::NewUpstreamSink {
394 #[allow(deprecated)]
395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
396 where
397 S: serde::Serializer,
398 {
399 use serde::ser::SerializeStruct;
400 let mut len = 0;
401 if self.info.is_some() {
402 len += 1;
403 }
404 if !self.upstream_actors.is_empty() {
405 len += 1;
406 }
407 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
408 if let Some(v) = self.info.as_ref() {
409 struct_ser.serialize_field("info", v)?;
410 }
411 if !self.upstream_actors.is_empty() {
412 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
413 }
414 struct_ser.end()
415 }
416}
417impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
418 #[allow(deprecated)]
419 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
420 where
421 D: serde::Deserializer<'de>,
422 {
423 const FIELDS: &[&str] = &[
424 "info",
425 "upstream_actors",
426 "upstreamActors",
427 ];
428
429 #[allow(clippy::enum_variant_names)]
430 enum GeneratedField {
431 Info,
432 UpstreamActors,
433 }
434 impl<'de> serde::Deserialize<'de> for GeneratedField {
435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
436 where
437 D: serde::Deserializer<'de>,
438 {
439 struct GeneratedVisitor;
440
441 impl serde::de::Visitor<'_> for GeneratedVisitor {
442 type Value = GeneratedField;
443
444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
445 write!(formatter, "expected one of: {:?}", &FIELDS)
446 }
447
448 #[allow(unused_variables)]
449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
450 where
451 E: serde::de::Error,
452 {
453 match value {
454 "info" => Ok(GeneratedField::Info),
455 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
457 }
458 }
459 }
460 deserializer.deserialize_identifier(GeneratedVisitor)
461 }
462 }
463 struct GeneratedVisitor;
464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
465 type Value = add_mutation::NewUpstreamSink;
466
467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
468 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
469 }
470
471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
472 where
473 V: serde::de::MapAccess<'de>,
474 {
475 let mut info__ = None;
476 let mut upstream_actors__ = None;
477 while let Some(k) = map_.next_key()? {
478 match k {
479 GeneratedField::Info => {
480 if info__.is_some() {
481 return Err(serde::de::Error::duplicate_field("info"));
482 }
483 info__ = map_.next_value()?;
484 }
485 GeneratedField::UpstreamActors => {
486 if upstream_actors__.is_some() {
487 return Err(serde::de::Error::duplicate_field("upstreamActors"));
488 }
489 upstream_actors__ = Some(map_.next_value()?);
490 }
491 }
492 }
493 Ok(add_mutation::NewUpstreamSink {
494 info: info__,
495 upstream_actors: upstream_actors__.unwrap_or_default(),
496 })
497 }
498 }
499 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
500 }
501}
502impl serde::Serialize for AggCallState {
503 #[allow(deprecated)]
504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
505 where
506 S: serde::Serializer,
507 {
508 use serde::ser::SerializeStruct;
509 let mut len = 0;
510 if self.inner.is_some() {
511 len += 1;
512 }
513 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
514 if let Some(v) = self.inner.as_ref() {
515 match v {
516 agg_call_state::Inner::ValueState(v) => {
517 struct_ser.serialize_field("valueState", v)?;
518 }
519 agg_call_state::Inner::MaterializedInputState(v) => {
520 struct_ser.serialize_field("materializedInputState", v)?;
521 }
522 }
523 }
524 struct_ser.end()
525 }
526}
527impl<'de> serde::Deserialize<'de> for AggCallState {
528 #[allow(deprecated)]
529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
530 where
531 D: serde::Deserializer<'de>,
532 {
533 const FIELDS: &[&str] = &[
534 "value_state",
535 "valueState",
536 "materialized_input_state",
537 "materializedInputState",
538 ];
539
540 #[allow(clippy::enum_variant_names)]
541 enum GeneratedField {
542 ValueState,
543 MaterializedInputState,
544 }
545 impl<'de> serde::Deserialize<'de> for GeneratedField {
546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
547 where
548 D: serde::Deserializer<'de>,
549 {
550 struct GeneratedVisitor;
551
552 impl serde::de::Visitor<'_> for GeneratedVisitor {
553 type Value = GeneratedField;
554
555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
556 write!(formatter, "expected one of: {:?}", &FIELDS)
557 }
558
559 #[allow(unused_variables)]
560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
561 where
562 E: serde::de::Error,
563 {
564 match value {
565 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
566 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
567 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
568 }
569 }
570 }
571 deserializer.deserialize_identifier(GeneratedVisitor)
572 }
573 }
574 struct GeneratedVisitor;
575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
576 type Value = AggCallState;
577
578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
579 formatter.write_str("struct stream_plan.AggCallState")
580 }
581
582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
583 where
584 V: serde::de::MapAccess<'de>,
585 {
586 let mut inner__ = None;
587 while let Some(k) = map_.next_key()? {
588 match k {
589 GeneratedField::ValueState => {
590 if inner__.is_some() {
591 return Err(serde::de::Error::duplicate_field("valueState"));
592 }
593 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
594;
595 }
596 GeneratedField::MaterializedInputState => {
597 if inner__.is_some() {
598 return Err(serde::de::Error::duplicate_field("materializedInputState"));
599 }
600 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
601;
602 }
603 }
604 }
605 Ok(AggCallState {
606 inner: inner__,
607 })
608 }
609 }
610 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
611 }
612}
613impl serde::Serialize for agg_call_state::MaterializedInputState {
614 #[allow(deprecated)]
615 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
616 where
617 S: serde::Serializer,
618 {
619 use serde::ser::SerializeStruct;
620 let mut len = 0;
621 if self.table.is_some() {
622 len += 1;
623 }
624 if !self.included_upstream_indices.is_empty() {
625 len += 1;
626 }
627 if !self.table_value_indices.is_empty() {
628 len += 1;
629 }
630 if !self.order_columns.is_empty() {
631 len += 1;
632 }
633 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
634 if let Some(v) = self.table.as_ref() {
635 struct_ser.serialize_field("table", v)?;
636 }
637 if !self.included_upstream_indices.is_empty() {
638 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
639 }
640 if !self.table_value_indices.is_empty() {
641 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
642 }
643 if !self.order_columns.is_empty() {
644 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
645 }
646 struct_ser.end()
647 }
648}
649impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
650 #[allow(deprecated)]
651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
652 where
653 D: serde::Deserializer<'de>,
654 {
655 const FIELDS: &[&str] = &[
656 "table",
657 "included_upstream_indices",
658 "includedUpstreamIndices",
659 "table_value_indices",
660 "tableValueIndices",
661 "order_columns",
662 "orderColumns",
663 ];
664
665 #[allow(clippy::enum_variant_names)]
666 enum GeneratedField {
667 Table,
668 IncludedUpstreamIndices,
669 TableValueIndices,
670 OrderColumns,
671 }
672 impl<'de> serde::Deserialize<'de> for GeneratedField {
673 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
674 where
675 D: serde::Deserializer<'de>,
676 {
677 struct GeneratedVisitor;
678
679 impl serde::de::Visitor<'_> for GeneratedVisitor {
680 type Value = GeneratedField;
681
682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
683 write!(formatter, "expected one of: {:?}", &FIELDS)
684 }
685
686 #[allow(unused_variables)]
687 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
688 where
689 E: serde::de::Error,
690 {
691 match value {
692 "table" => Ok(GeneratedField::Table),
693 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
694 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
695 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
696 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
697 }
698 }
699 }
700 deserializer.deserialize_identifier(GeneratedVisitor)
701 }
702 }
703 struct GeneratedVisitor;
704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
705 type Value = agg_call_state::MaterializedInputState;
706
707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
708 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
709 }
710
711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
712 where
713 V: serde::de::MapAccess<'de>,
714 {
715 let mut table__ = None;
716 let mut included_upstream_indices__ = None;
717 let mut table_value_indices__ = None;
718 let mut order_columns__ = None;
719 while let Some(k) = map_.next_key()? {
720 match k {
721 GeneratedField::Table => {
722 if table__.is_some() {
723 return Err(serde::de::Error::duplicate_field("table"));
724 }
725 table__ = map_.next_value()?;
726 }
727 GeneratedField::IncludedUpstreamIndices => {
728 if included_upstream_indices__.is_some() {
729 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
730 }
731 included_upstream_indices__ =
732 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
733 .into_iter().map(|x| x.0).collect())
734 ;
735 }
736 GeneratedField::TableValueIndices => {
737 if table_value_indices__.is_some() {
738 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
739 }
740 table_value_indices__ =
741 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
742 .into_iter().map(|x| x.0).collect())
743 ;
744 }
745 GeneratedField::OrderColumns => {
746 if order_columns__.is_some() {
747 return Err(serde::de::Error::duplicate_field("orderColumns"));
748 }
749 order_columns__ = Some(map_.next_value()?);
750 }
751 }
752 }
753 Ok(agg_call_state::MaterializedInputState {
754 table: table__,
755 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
756 table_value_indices: table_value_indices__.unwrap_or_default(),
757 order_columns: order_columns__.unwrap_or_default(),
758 })
759 }
760 }
761 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
762 }
763}
764impl serde::Serialize for agg_call_state::ValueState {
765 #[allow(deprecated)]
766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
767 where
768 S: serde::Serializer,
769 {
770 use serde::ser::SerializeStruct;
771 let len = 0;
772 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
773 struct_ser.end()
774 }
775}
776impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
777 #[allow(deprecated)]
778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
779 where
780 D: serde::Deserializer<'de>,
781 {
782 const FIELDS: &[&str] = &[
783 ];
784
785 #[allow(clippy::enum_variant_names)]
786 enum GeneratedField {
787 }
788 impl<'de> serde::Deserialize<'de> for GeneratedField {
789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
790 where
791 D: serde::Deserializer<'de>,
792 {
793 struct GeneratedVisitor;
794
795 impl serde::de::Visitor<'_> for GeneratedVisitor {
796 type Value = GeneratedField;
797
798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
799 write!(formatter, "expected one of: {:?}", &FIELDS)
800 }
801
802 #[allow(unused_variables)]
803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
804 where
805 E: serde::de::Error,
806 {
807 Err(serde::de::Error::unknown_field(value, FIELDS))
808 }
809 }
810 deserializer.deserialize_identifier(GeneratedVisitor)
811 }
812 }
813 struct GeneratedVisitor;
814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
815 type Value = agg_call_state::ValueState;
816
817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
818 formatter.write_str("struct stream_plan.AggCallState.ValueState")
819 }
820
821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
822 where
823 V: serde::de::MapAccess<'de>,
824 {
825 while map_.next_key::<GeneratedField>()?.is_some() {
826 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
827 }
828 Ok(agg_call_state::ValueState {
829 })
830 }
831 }
832 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
833 }
834}
835impl serde::Serialize for AggNodeVersion {
836 #[allow(deprecated)]
837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
838 where
839 S: serde::Serializer,
840 {
841 let variant = match self {
842 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
843 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
844 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
845 };
846 serializer.serialize_str(variant)
847 }
848}
849impl<'de> serde::Deserialize<'de> for AggNodeVersion {
850 #[allow(deprecated)]
851 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
852 where
853 D: serde::Deserializer<'de>,
854 {
855 const FIELDS: &[&str] = &[
856 "AGG_NODE_VERSION_UNSPECIFIED",
857 "AGG_NODE_VERSION_ISSUE_12140",
858 "AGG_NODE_VERSION_ISSUE_13465",
859 ];
860
861 struct GeneratedVisitor;
862
863 impl serde::de::Visitor<'_> for GeneratedVisitor {
864 type Value = AggNodeVersion;
865
866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
867 write!(formatter, "expected one of: {:?}", &FIELDS)
868 }
869
870 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
871 where
872 E: serde::de::Error,
873 {
874 i32::try_from(v)
875 .ok()
876 .and_then(|x| x.try_into().ok())
877 .ok_or_else(|| {
878 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
879 })
880 }
881
882 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
883 where
884 E: serde::de::Error,
885 {
886 i32::try_from(v)
887 .ok()
888 .and_then(|x| x.try_into().ok())
889 .ok_or_else(|| {
890 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
891 })
892 }
893
894 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
895 where
896 E: serde::de::Error,
897 {
898 match value {
899 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
900 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
901 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
902 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
903 }
904 }
905 }
906 deserializer.deserialize_any(GeneratedVisitor)
907 }
908}
909impl serde::Serialize for ArrangeNode {
910 #[allow(deprecated)]
911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
912 where
913 S: serde::Serializer,
914 {
915 use serde::ser::SerializeStruct;
916 let mut len = 0;
917 if self.table_info.is_some() {
918 len += 1;
919 }
920 if !self.distribution_key.is_empty() {
921 len += 1;
922 }
923 if self.table.is_some() {
924 len += 1;
925 }
926 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
927 if let Some(v) = self.table_info.as_ref() {
928 struct_ser.serialize_field("tableInfo", v)?;
929 }
930 if !self.distribution_key.is_empty() {
931 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
932 }
933 if let Some(v) = self.table.as_ref() {
934 struct_ser.serialize_field("table", v)?;
935 }
936 struct_ser.end()
937 }
938}
939impl<'de> serde::Deserialize<'de> for ArrangeNode {
940 #[allow(deprecated)]
941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
942 where
943 D: serde::Deserializer<'de>,
944 {
945 const FIELDS: &[&str] = &[
946 "table_info",
947 "tableInfo",
948 "distribution_key",
949 "distributionKey",
950 "table",
951 ];
952
953 #[allow(clippy::enum_variant_names)]
954 enum GeneratedField {
955 TableInfo,
956 DistributionKey,
957 Table,
958 }
959 impl<'de> serde::Deserialize<'de> for GeneratedField {
960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
961 where
962 D: serde::Deserializer<'de>,
963 {
964 struct GeneratedVisitor;
965
966 impl serde::de::Visitor<'_> for GeneratedVisitor {
967 type Value = GeneratedField;
968
969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
970 write!(formatter, "expected one of: {:?}", &FIELDS)
971 }
972
973 #[allow(unused_variables)]
974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
975 where
976 E: serde::de::Error,
977 {
978 match value {
979 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
980 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
981 "table" => Ok(GeneratedField::Table),
982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
983 }
984 }
985 }
986 deserializer.deserialize_identifier(GeneratedVisitor)
987 }
988 }
989 struct GeneratedVisitor;
990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
991 type Value = ArrangeNode;
992
993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
994 formatter.write_str("struct stream_plan.ArrangeNode")
995 }
996
997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
998 where
999 V: serde::de::MapAccess<'de>,
1000 {
1001 let mut table_info__ = None;
1002 let mut distribution_key__ = None;
1003 let mut table__ = None;
1004 while let Some(k) = map_.next_key()? {
1005 match k {
1006 GeneratedField::TableInfo => {
1007 if table_info__.is_some() {
1008 return Err(serde::de::Error::duplicate_field("tableInfo"));
1009 }
1010 table_info__ = map_.next_value()?;
1011 }
1012 GeneratedField::DistributionKey => {
1013 if distribution_key__.is_some() {
1014 return Err(serde::de::Error::duplicate_field("distributionKey"));
1015 }
1016 distribution_key__ =
1017 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1018 .into_iter().map(|x| x.0).collect())
1019 ;
1020 }
1021 GeneratedField::Table => {
1022 if table__.is_some() {
1023 return Err(serde::de::Error::duplicate_field("table"));
1024 }
1025 table__ = map_.next_value()?;
1026 }
1027 }
1028 }
1029 Ok(ArrangeNode {
1030 table_info: table_info__,
1031 distribution_key: distribution_key__.unwrap_or_default(),
1032 table: table__,
1033 })
1034 }
1035 }
1036 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
1037 }
1038}
1039impl serde::Serialize for ArrangementInfo {
1040 #[allow(deprecated)]
1041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1042 where
1043 S: serde::Serializer,
1044 {
1045 use serde::ser::SerializeStruct;
1046 let mut len = 0;
1047 if !self.arrange_key_orders.is_empty() {
1048 len += 1;
1049 }
1050 if !self.column_descs.is_empty() {
1051 len += 1;
1052 }
1053 if self.table_desc.is_some() {
1054 len += 1;
1055 }
1056 if !self.output_col_idx.is_empty() {
1057 len += 1;
1058 }
1059 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1060 if !self.arrange_key_orders.is_empty() {
1061 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1062 }
1063 if !self.column_descs.is_empty() {
1064 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1065 }
1066 if let Some(v) = self.table_desc.as_ref() {
1067 struct_ser.serialize_field("tableDesc", v)?;
1068 }
1069 if !self.output_col_idx.is_empty() {
1070 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1071 }
1072 struct_ser.end()
1073 }
1074}
1075impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1076 #[allow(deprecated)]
1077 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1078 where
1079 D: serde::Deserializer<'de>,
1080 {
1081 const FIELDS: &[&str] = &[
1082 "arrange_key_orders",
1083 "arrangeKeyOrders",
1084 "column_descs",
1085 "columnDescs",
1086 "table_desc",
1087 "tableDesc",
1088 "output_col_idx",
1089 "outputColIdx",
1090 ];
1091
1092 #[allow(clippy::enum_variant_names)]
1093 enum GeneratedField {
1094 ArrangeKeyOrders,
1095 ColumnDescs,
1096 TableDesc,
1097 OutputColIdx,
1098 }
1099 impl<'de> serde::Deserialize<'de> for GeneratedField {
1100 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1101 where
1102 D: serde::Deserializer<'de>,
1103 {
1104 struct GeneratedVisitor;
1105
1106 impl serde::de::Visitor<'_> for GeneratedVisitor {
1107 type Value = GeneratedField;
1108
1109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1110 write!(formatter, "expected one of: {:?}", &FIELDS)
1111 }
1112
1113 #[allow(unused_variables)]
1114 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1115 where
1116 E: serde::de::Error,
1117 {
1118 match value {
1119 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1120 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1121 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1122 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1124 }
1125 }
1126 }
1127 deserializer.deserialize_identifier(GeneratedVisitor)
1128 }
1129 }
1130 struct GeneratedVisitor;
1131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1132 type Value = ArrangementInfo;
1133
1134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1135 formatter.write_str("struct stream_plan.ArrangementInfo")
1136 }
1137
1138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1139 where
1140 V: serde::de::MapAccess<'de>,
1141 {
1142 let mut arrange_key_orders__ = None;
1143 let mut column_descs__ = None;
1144 let mut table_desc__ = None;
1145 let mut output_col_idx__ = None;
1146 while let Some(k) = map_.next_key()? {
1147 match k {
1148 GeneratedField::ArrangeKeyOrders => {
1149 if arrange_key_orders__.is_some() {
1150 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1151 }
1152 arrange_key_orders__ = Some(map_.next_value()?);
1153 }
1154 GeneratedField::ColumnDescs => {
1155 if column_descs__.is_some() {
1156 return Err(serde::de::Error::duplicate_field("columnDescs"));
1157 }
1158 column_descs__ = Some(map_.next_value()?);
1159 }
1160 GeneratedField::TableDesc => {
1161 if table_desc__.is_some() {
1162 return Err(serde::de::Error::duplicate_field("tableDesc"));
1163 }
1164 table_desc__ = map_.next_value()?;
1165 }
1166 GeneratedField::OutputColIdx => {
1167 if output_col_idx__.is_some() {
1168 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1169 }
1170 output_col_idx__ =
1171 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1172 .into_iter().map(|x| x.0).collect())
1173 ;
1174 }
1175 }
1176 }
1177 Ok(ArrangementInfo {
1178 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1179 column_descs: column_descs__.unwrap_or_default(),
1180 table_desc: table_desc__,
1181 output_col_idx: output_col_idx__.unwrap_or_default(),
1182 })
1183 }
1184 }
1185 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1186 }
1187}
1188impl serde::Serialize for AsOfJoinNode {
1189 #[allow(deprecated)]
1190 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1191 where
1192 S: serde::Serializer,
1193 {
1194 use serde::ser::SerializeStruct;
1195 let mut len = 0;
1196 if self.join_type != 0 {
1197 len += 1;
1198 }
1199 if !self.left_key.is_empty() {
1200 len += 1;
1201 }
1202 if !self.right_key.is_empty() {
1203 len += 1;
1204 }
1205 if self.left_table.is_some() {
1206 len += 1;
1207 }
1208 if self.right_table.is_some() {
1209 len += 1;
1210 }
1211 if !self.output_indices.is_empty() {
1212 len += 1;
1213 }
1214 if !self.left_deduped_input_pk_indices.is_empty() {
1215 len += 1;
1216 }
1217 if !self.right_deduped_input_pk_indices.is_empty() {
1218 len += 1;
1219 }
1220 if !self.null_safe.is_empty() {
1221 len += 1;
1222 }
1223 if self.asof_desc.is_some() {
1224 len += 1;
1225 }
1226 if self.join_encoding_type != 0 {
1227 len += 1;
1228 }
1229 if self.use_cache.is_some() {
1230 len += 1;
1231 }
1232 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1233 if self.join_type != 0 {
1234 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1235 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1236 struct_ser.serialize_field("joinType", &v)?;
1237 }
1238 if !self.left_key.is_empty() {
1239 struct_ser.serialize_field("leftKey", &self.left_key)?;
1240 }
1241 if !self.right_key.is_empty() {
1242 struct_ser.serialize_field("rightKey", &self.right_key)?;
1243 }
1244 if let Some(v) = self.left_table.as_ref() {
1245 struct_ser.serialize_field("leftTable", v)?;
1246 }
1247 if let Some(v) = self.right_table.as_ref() {
1248 struct_ser.serialize_field("rightTable", v)?;
1249 }
1250 if !self.output_indices.is_empty() {
1251 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1252 }
1253 if !self.left_deduped_input_pk_indices.is_empty() {
1254 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1255 }
1256 if !self.right_deduped_input_pk_indices.is_empty() {
1257 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1258 }
1259 if !self.null_safe.is_empty() {
1260 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1261 }
1262 if let Some(v) = self.asof_desc.as_ref() {
1263 struct_ser.serialize_field("asofDesc", v)?;
1264 }
1265 if self.join_encoding_type != 0 {
1266 let v = JoinEncodingType::try_from(self.join_encoding_type)
1267 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1268 struct_ser.serialize_field("joinEncodingType", &v)?;
1269 }
1270 if let Some(v) = self.use_cache.as_ref() {
1271 struct_ser.serialize_field("useCache", v)?;
1272 }
1273 struct_ser.end()
1274 }
1275}
1276impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1277 #[allow(deprecated)]
1278 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1279 where
1280 D: serde::Deserializer<'de>,
1281 {
1282 const FIELDS: &[&str] = &[
1283 "join_type",
1284 "joinType",
1285 "left_key",
1286 "leftKey",
1287 "right_key",
1288 "rightKey",
1289 "left_table",
1290 "leftTable",
1291 "right_table",
1292 "rightTable",
1293 "output_indices",
1294 "outputIndices",
1295 "left_deduped_input_pk_indices",
1296 "leftDedupedInputPkIndices",
1297 "right_deduped_input_pk_indices",
1298 "rightDedupedInputPkIndices",
1299 "null_safe",
1300 "nullSafe",
1301 "asof_desc",
1302 "asofDesc",
1303 "join_encoding_type",
1304 "joinEncodingType",
1305 "use_cache",
1306 "useCache",
1307 ];
1308
1309 #[allow(clippy::enum_variant_names)]
1310 enum GeneratedField {
1311 JoinType,
1312 LeftKey,
1313 RightKey,
1314 LeftTable,
1315 RightTable,
1316 OutputIndices,
1317 LeftDedupedInputPkIndices,
1318 RightDedupedInputPkIndices,
1319 NullSafe,
1320 AsofDesc,
1321 JoinEncodingType,
1322 UseCache,
1323 }
1324 impl<'de> serde::Deserialize<'de> for GeneratedField {
1325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1326 where
1327 D: serde::Deserializer<'de>,
1328 {
1329 struct GeneratedVisitor;
1330
1331 impl serde::de::Visitor<'_> for GeneratedVisitor {
1332 type Value = GeneratedField;
1333
1334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1335 write!(formatter, "expected one of: {:?}", &FIELDS)
1336 }
1337
1338 #[allow(unused_variables)]
1339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1340 where
1341 E: serde::de::Error,
1342 {
1343 match value {
1344 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1345 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1346 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1347 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1348 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1349 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1350 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1351 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1352 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1353 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1354 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1355 "useCache" | "use_cache" => Ok(GeneratedField::UseCache),
1356 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1357 }
1358 }
1359 }
1360 deserializer.deserialize_identifier(GeneratedVisitor)
1361 }
1362 }
1363 struct GeneratedVisitor;
1364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1365 type Value = AsOfJoinNode;
1366
1367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1368 formatter.write_str("struct stream_plan.AsOfJoinNode")
1369 }
1370
1371 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1372 where
1373 V: serde::de::MapAccess<'de>,
1374 {
1375 let mut join_type__ = None;
1376 let mut left_key__ = None;
1377 let mut right_key__ = None;
1378 let mut left_table__ = None;
1379 let mut right_table__ = None;
1380 let mut output_indices__ = None;
1381 let mut left_deduped_input_pk_indices__ = None;
1382 let mut right_deduped_input_pk_indices__ = None;
1383 let mut null_safe__ = None;
1384 let mut asof_desc__ = None;
1385 let mut join_encoding_type__ = None;
1386 let mut use_cache__ = None;
1387 while let Some(k) = map_.next_key()? {
1388 match k {
1389 GeneratedField::JoinType => {
1390 if join_type__.is_some() {
1391 return Err(serde::de::Error::duplicate_field("joinType"));
1392 }
1393 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1394 }
1395 GeneratedField::LeftKey => {
1396 if left_key__.is_some() {
1397 return Err(serde::de::Error::duplicate_field("leftKey"));
1398 }
1399 left_key__ =
1400 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1401 .into_iter().map(|x| x.0).collect())
1402 ;
1403 }
1404 GeneratedField::RightKey => {
1405 if right_key__.is_some() {
1406 return Err(serde::de::Error::duplicate_field("rightKey"));
1407 }
1408 right_key__ =
1409 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1410 .into_iter().map(|x| x.0).collect())
1411 ;
1412 }
1413 GeneratedField::LeftTable => {
1414 if left_table__.is_some() {
1415 return Err(serde::de::Error::duplicate_field("leftTable"));
1416 }
1417 left_table__ = map_.next_value()?;
1418 }
1419 GeneratedField::RightTable => {
1420 if right_table__.is_some() {
1421 return Err(serde::de::Error::duplicate_field("rightTable"));
1422 }
1423 right_table__ = map_.next_value()?;
1424 }
1425 GeneratedField::OutputIndices => {
1426 if output_indices__.is_some() {
1427 return Err(serde::de::Error::duplicate_field("outputIndices"));
1428 }
1429 output_indices__ =
1430 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1431 .into_iter().map(|x| x.0).collect())
1432 ;
1433 }
1434 GeneratedField::LeftDedupedInputPkIndices => {
1435 if left_deduped_input_pk_indices__.is_some() {
1436 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1437 }
1438 left_deduped_input_pk_indices__ =
1439 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1440 .into_iter().map(|x| x.0).collect())
1441 ;
1442 }
1443 GeneratedField::RightDedupedInputPkIndices => {
1444 if right_deduped_input_pk_indices__.is_some() {
1445 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1446 }
1447 right_deduped_input_pk_indices__ =
1448 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1449 .into_iter().map(|x| x.0).collect())
1450 ;
1451 }
1452 GeneratedField::NullSafe => {
1453 if null_safe__.is_some() {
1454 return Err(serde::de::Error::duplicate_field("nullSafe"));
1455 }
1456 null_safe__ = Some(map_.next_value()?);
1457 }
1458 GeneratedField::AsofDesc => {
1459 if asof_desc__.is_some() {
1460 return Err(serde::de::Error::duplicate_field("asofDesc"));
1461 }
1462 asof_desc__ = map_.next_value()?;
1463 }
1464 GeneratedField::JoinEncodingType => {
1465 if join_encoding_type__.is_some() {
1466 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1467 }
1468 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1469 }
1470 GeneratedField::UseCache => {
1471 if use_cache__.is_some() {
1472 return Err(serde::de::Error::duplicate_field("useCache"));
1473 }
1474 use_cache__ = map_.next_value()?;
1475 }
1476 }
1477 }
1478 Ok(AsOfJoinNode {
1479 join_type: join_type__.unwrap_or_default(),
1480 left_key: left_key__.unwrap_or_default(),
1481 right_key: right_key__.unwrap_or_default(),
1482 left_table: left_table__,
1483 right_table: right_table__,
1484 output_indices: output_indices__.unwrap_or_default(),
1485 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1486 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1487 null_safe: null_safe__.unwrap_or_default(),
1488 asof_desc: asof_desc__,
1489 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1490 use_cache: use_cache__,
1491 })
1492 }
1493 }
1494 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1495 }
1496}
1497impl serde::Serialize for BackfillOrder {
1498 #[allow(deprecated)]
1499 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1500 where
1501 S: serde::Serializer,
1502 {
1503 use serde::ser::SerializeStruct;
1504 let mut len = 0;
1505 if !self.order.is_empty() {
1506 len += 1;
1507 }
1508 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1509 if !self.order.is_empty() {
1510 struct_ser.serialize_field("order", &self.order)?;
1511 }
1512 struct_ser.end()
1513 }
1514}
1515impl<'de> serde::Deserialize<'de> for BackfillOrder {
1516 #[allow(deprecated)]
1517 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1518 where
1519 D: serde::Deserializer<'de>,
1520 {
1521 const FIELDS: &[&str] = &[
1522 "order",
1523 ];
1524
1525 #[allow(clippy::enum_variant_names)]
1526 enum GeneratedField {
1527 Order,
1528 }
1529 impl<'de> serde::Deserialize<'de> for GeneratedField {
1530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1531 where
1532 D: serde::Deserializer<'de>,
1533 {
1534 struct GeneratedVisitor;
1535
1536 impl serde::de::Visitor<'_> for GeneratedVisitor {
1537 type Value = GeneratedField;
1538
1539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1540 write!(formatter, "expected one of: {:?}", &FIELDS)
1541 }
1542
1543 #[allow(unused_variables)]
1544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1545 where
1546 E: serde::de::Error,
1547 {
1548 match value {
1549 "order" => Ok(GeneratedField::Order),
1550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1551 }
1552 }
1553 }
1554 deserializer.deserialize_identifier(GeneratedVisitor)
1555 }
1556 }
1557 struct GeneratedVisitor;
1558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1559 type Value = BackfillOrder;
1560
1561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1562 formatter.write_str("struct stream_plan.BackfillOrder")
1563 }
1564
1565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1566 where
1567 V: serde::de::MapAccess<'de>,
1568 {
1569 let mut order__ = None;
1570 while let Some(k) = map_.next_key()? {
1571 match k {
1572 GeneratedField::Order => {
1573 if order__.is_some() {
1574 return Err(serde::de::Error::duplicate_field("order"));
1575 }
1576 order__ = Some(
1577 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1578 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1579 );
1580 }
1581 }
1582 }
1583 Ok(BackfillOrder {
1584 order: order__.unwrap_or_default(),
1585 })
1586 }
1587 }
1588 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1589 }
1590}
1591impl serde::Serialize for Barrier {
1592 #[allow(deprecated)]
1593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1594 where
1595 S: serde::Serializer,
1596 {
1597 use serde::ser::SerializeStruct;
1598 let mut len = 0;
1599 if self.epoch.is_some() {
1600 len += 1;
1601 }
1602 if self.mutation.is_some() {
1603 len += 1;
1604 }
1605 if !self.tracing_context.is_empty() {
1606 len += 1;
1607 }
1608 if self.kind != 0 {
1609 len += 1;
1610 }
1611 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1612 if let Some(v) = self.epoch.as_ref() {
1613 struct_ser.serialize_field("epoch", v)?;
1614 }
1615 if let Some(v) = self.mutation.as_ref() {
1616 struct_ser.serialize_field("mutation", v)?;
1617 }
1618 if !self.tracing_context.is_empty() {
1619 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1620 }
1621 if self.kind != 0 {
1622 let v = barrier::BarrierKind::try_from(self.kind)
1623 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1624 struct_ser.serialize_field("kind", &v)?;
1625 }
1626 struct_ser.end()
1627 }
1628}
1629impl<'de> serde::Deserialize<'de> for Barrier {
1630 #[allow(deprecated)]
1631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1632 where
1633 D: serde::Deserializer<'de>,
1634 {
1635 const FIELDS: &[&str] = &[
1636 "epoch",
1637 "mutation",
1638 "tracing_context",
1639 "tracingContext",
1640 "kind",
1641 ];
1642
1643 #[allow(clippy::enum_variant_names)]
1644 enum GeneratedField {
1645 Epoch,
1646 Mutation,
1647 TracingContext,
1648 Kind,
1649 }
1650 impl<'de> serde::Deserialize<'de> for GeneratedField {
1651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1652 where
1653 D: serde::Deserializer<'de>,
1654 {
1655 struct GeneratedVisitor;
1656
1657 impl serde::de::Visitor<'_> for GeneratedVisitor {
1658 type Value = GeneratedField;
1659
1660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1661 write!(formatter, "expected one of: {:?}", &FIELDS)
1662 }
1663
1664 #[allow(unused_variables)]
1665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1666 where
1667 E: serde::de::Error,
1668 {
1669 match value {
1670 "epoch" => Ok(GeneratedField::Epoch),
1671 "mutation" => Ok(GeneratedField::Mutation),
1672 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1673 "kind" => Ok(GeneratedField::Kind),
1674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1675 }
1676 }
1677 }
1678 deserializer.deserialize_identifier(GeneratedVisitor)
1679 }
1680 }
1681 struct GeneratedVisitor;
1682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1683 type Value = Barrier;
1684
1685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1686 formatter.write_str("struct stream_plan.Barrier")
1687 }
1688
1689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1690 where
1691 V: serde::de::MapAccess<'de>,
1692 {
1693 let mut epoch__ = None;
1694 let mut mutation__ = None;
1695 let mut tracing_context__ = None;
1696 let mut kind__ = None;
1697 while let Some(k) = map_.next_key()? {
1698 match k {
1699 GeneratedField::Epoch => {
1700 if epoch__.is_some() {
1701 return Err(serde::de::Error::duplicate_field("epoch"));
1702 }
1703 epoch__ = map_.next_value()?;
1704 }
1705 GeneratedField::Mutation => {
1706 if mutation__.is_some() {
1707 return Err(serde::de::Error::duplicate_field("mutation"));
1708 }
1709 mutation__ = map_.next_value()?;
1710 }
1711 GeneratedField::TracingContext => {
1712 if tracing_context__.is_some() {
1713 return Err(serde::de::Error::duplicate_field("tracingContext"));
1714 }
1715 tracing_context__ = Some(
1716 map_.next_value::<std::collections::HashMap<_, _>>()?
1717 );
1718 }
1719 GeneratedField::Kind => {
1720 if kind__.is_some() {
1721 return Err(serde::de::Error::duplicate_field("kind"));
1722 }
1723 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1724 }
1725 }
1726 }
1727 Ok(Barrier {
1728 epoch: epoch__,
1729 mutation: mutation__,
1730 tracing_context: tracing_context__.unwrap_or_default(),
1731 kind: kind__.unwrap_or_default(),
1732 })
1733 }
1734 }
1735 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1736 }
1737}
1738impl serde::Serialize for barrier::BarrierKind {
1739 #[allow(deprecated)]
1740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1741 where
1742 S: serde::Serializer,
1743 {
1744 let variant = match self {
1745 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1746 Self::Initial => "BARRIER_KIND_INITIAL",
1747 Self::Barrier => "BARRIER_KIND_BARRIER",
1748 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1749 };
1750 serializer.serialize_str(variant)
1751 }
1752}
1753impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1754 #[allow(deprecated)]
1755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1756 where
1757 D: serde::Deserializer<'de>,
1758 {
1759 const FIELDS: &[&str] = &[
1760 "BARRIER_KIND_UNSPECIFIED",
1761 "BARRIER_KIND_INITIAL",
1762 "BARRIER_KIND_BARRIER",
1763 "BARRIER_KIND_CHECKPOINT",
1764 ];
1765
1766 struct GeneratedVisitor;
1767
1768 impl serde::de::Visitor<'_> for GeneratedVisitor {
1769 type Value = barrier::BarrierKind;
1770
1771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1772 write!(formatter, "expected one of: {:?}", &FIELDS)
1773 }
1774
1775 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1776 where
1777 E: serde::de::Error,
1778 {
1779 i32::try_from(v)
1780 .ok()
1781 .and_then(|x| x.try_into().ok())
1782 .ok_or_else(|| {
1783 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1784 })
1785 }
1786
1787 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1788 where
1789 E: serde::de::Error,
1790 {
1791 i32::try_from(v)
1792 .ok()
1793 .and_then(|x| x.try_into().ok())
1794 .ok_or_else(|| {
1795 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1796 })
1797 }
1798
1799 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1800 where
1801 E: serde::de::Error,
1802 {
1803 match value {
1804 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1805 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1806 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1807 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1808 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1809 }
1810 }
1811 }
1812 deserializer.deserialize_any(GeneratedVisitor)
1813 }
1814}
1815impl serde::Serialize for BarrierMutation {
1816 #[allow(deprecated)]
1817 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1818 where
1819 S: serde::Serializer,
1820 {
1821 use serde::ser::SerializeStruct;
1822 let mut len = 0;
1823 if self.mutation.is_some() {
1824 len += 1;
1825 }
1826 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1827 if let Some(v) = self.mutation.as_ref() {
1828 match v {
1829 barrier_mutation::Mutation::Add(v) => {
1830 struct_ser.serialize_field("add", v)?;
1831 }
1832 barrier_mutation::Mutation::Stop(v) => {
1833 struct_ser.serialize_field("stop", v)?;
1834 }
1835 barrier_mutation::Mutation::Update(v) => {
1836 struct_ser.serialize_field("update", v)?;
1837 }
1838 barrier_mutation::Mutation::Splits(v) => {
1839 struct_ser.serialize_field("splits", v)?;
1840 }
1841 barrier_mutation::Mutation::Pause(v) => {
1842 struct_ser.serialize_field("pause", v)?;
1843 }
1844 barrier_mutation::Mutation::Resume(v) => {
1845 struct_ser.serialize_field("resume", v)?;
1846 }
1847 barrier_mutation::Mutation::Throttle(v) => {
1848 struct_ser.serialize_field("throttle", v)?;
1849 }
1850 barrier_mutation::Mutation::DropSubscriptions(v) => {
1851 struct_ser.serialize_field("dropSubscriptions", v)?;
1852 }
1853 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1854 struct_ser.serialize_field("connectorPropsChange", v)?;
1855 }
1856 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1857 struct_ser.serialize_field("startFragmentBackfill", v)?;
1858 }
1859 barrier_mutation::Mutation::RefreshStart(v) => {
1860 struct_ser.serialize_field("refreshStart", v)?;
1861 }
1862 barrier_mutation::Mutation::LoadFinish(v) => {
1863 struct_ser.serialize_field("loadFinish", v)?;
1864 }
1865 barrier_mutation::Mutation::ListFinish(v) => {
1866 struct_ser.serialize_field("listFinish", v)?;
1867 }
1868 barrier_mutation::Mutation::ResetSource(v) => {
1869 struct_ser.serialize_field("resetSource", v)?;
1870 }
1871 barrier_mutation::Mutation::InjectSourceOffsets(v) => {
1872 struct_ser.serialize_field("injectSourceOffsets", v)?;
1873 }
1874 }
1875 }
1876 struct_ser.end()
1877 }
1878}
1879impl<'de> serde::Deserialize<'de> for BarrierMutation {
1880 #[allow(deprecated)]
1881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1882 where
1883 D: serde::Deserializer<'de>,
1884 {
1885 const FIELDS: &[&str] = &[
1886 "add",
1887 "stop",
1888 "update",
1889 "splits",
1890 "pause",
1891 "resume",
1892 "throttle",
1893 "drop_subscriptions",
1894 "dropSubscriptions",
1895 "connector_props_change",
1896 "connectorPropsChange",
1897 "start_fragment_backfill",
1898 "startFragmentBackfill",
1899 "refresh_start",
1900 "refreshStart",
1901 "load_finish",
1902 "loadFinish",
1903 "list_finish",
1904 "listFinish",
1905 "reset_source",
1906 "resetSource",
1907 "inject_source_offsets",
1908 "injectSourceOffsets",
1909 ];
1910
1911 #[allow(clippy::enum_variant_names)]
1912 enum GeneratedField {
1913 Add,
1914 Stop,
1915 Update,
1916 Splits,
1917 Pause,
1918 Resume,
1919 Throttle,
1920 DropSubscriptions,
1921 ConnectorPropsChange,
1922 StartFragmentBackfill,
1923 RefreshStart,
1924 LoadFinish,
1925 ListFinish,
1926 ResetSource,
1927 InjectSourceOffsets,
1928 }
1929 impl<'de> serde::Deserialize<'de> for GeneratedField {
1930 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1931 where
1932 D: serde::Deserializer<'de>,
1933 {
1934 struct GeneratedVisitor;
1935
1936 impl serde::de::Visitor<'_> for GeneratedVisitor {
1937 type Value = GeneratedField;
1938
1939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1940 write!(formatter, "expected one of: {:?}", &FIELDS)
1941 }
1942
1943 #[allow(unused_variables)]
1944 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1945 where
1946 E: serde::de::Error,
1947 {
1948 match value {
1949 "add" => Ok(GeneratedField::Add),
1950 "stop" => Ok(GeneratedField::Stop),
1951 "update" => Ok(GeneratedField::Update),
1952 "splits" => Ok(GeneratedField::Splits),
1953 "pause" => Ok(GeneratedField::Pause),
1954 "resume" => Ok(GeneratedField::Resume),
1955 "throttle" => Ok(GeneratedField::Throttle),
1956 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1957 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1958 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1959 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1960 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1961 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1962 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1963 "injectSourceOffsets" | "inject_source_offsets" => Ok(GeneratedField::InjectSourceOffsets),
1964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1965 }
1966 }
1967 }
1968 deserializer.deserialize_identifier(GeneratedVisitor)
1969 }
1970 }
1971 struct GeneratedVisitor;
1972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1973 type Value = BarrierMutation;
1974
1975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1976 formatter.write_str("struct stream_plan.BarrierMutation")
1977 }
1978
1979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1980 where
1981 V: serde::de::MapAccess<'de>,
1982 {
1983 let mut mutation__ = None;
1984 while let Some(k) = map_.next_key()? {
1985 match k {
1986 GeneratedField::Add => {
1987 if mutation__.is_some() {
1988 return Err(serde::de::Error::duplicate_field("add"));
1989 }
1990 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1991;
1992 }
1993 GeneratedField::Stop => {
1994 if mutation__.is_some() {
1995 return Err(serde::de::Error::duplicate_field("stop"));
1996 }
1997 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1998;
1999 }
2000 GeneratedField::Update => {
2001 if mutation__.is_some() {
2002 return Err(serde::de::Error::duplicate_field("update"));
2003 }
2004 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
2005;
2006 }
2007 GeneratedField::Splits => {
2008 if mutation__.is_some() {
2009 return Err(serde::de::Error::duplicate_field("splits"));
2010 }
2011 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
2012;
2013 }
2014 GeneratedField::Pause => {
2015 if mutation__.is_some() {
2016 return Err(serde::de::Error::duplicate_field("pause"));
2017 }
2018 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
2019;
2020 }
2021 GeneratedField::Resume => {
2022 if mutation__.is_some() {
2023 return Err(serde::de::Error::duplicate_field("resume"));
2024 }
2025 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
2026;
2027 }
2028 GeneratedField::Throttle => {
2029 if mutation__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("throttle"));
2031 }
2032 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
2033;
2034 }
2035 GeneratedField::DropSubscriptions => {
2036 if mutation__.is_some() {
2037 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
2038 }
2039 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
2040;
2041 }
2042 GeneratedField::ConnectorPropsChange => {
2043 if mutation__.is_some() {
2044 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
2045 }
2046 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
2047;
2048 }
2049 GeneratedField::StartFragmentBackfill => {
2050 if mutation__.is_some() {
2051 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
2052 }
2053 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
2054;
2055 }
2056 GeneratedField::RefreshStart => {
2057 if mutation__.is_some() {
2058 return Err(serde::de::Error::duplicate_field("refreshStart"));
2059 }
2060 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2061;
2062 }
2063 GeneratedField::LoadFinish => {
2064 if mutation__.is_some() {
2065 return Err(serde::de::Error::duplicate_field("loadFinish"));
2066 }
2067 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2068;
2069 }
2070 GeneratedField::ListFinish => {
2071 if mutation__.is_some() {
2072 return Err(serde::de::Error::duplicate_field("listFinish"));
2073 }
2074 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2075;
2076 }
2077 GeneratedField::ResetSource => {
2078 if mutation__.is_some() {
2079 return Err(serde::de::Error::duplicate_field("resetSource"));
2080 }
2081 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2082;
2083 }
2084 GeneratedField::InjectSourceOffsets => {
2085 if mutation__.is_some() {
2086 return Err(serde::de::Error::duplicate_field("injectSourceOffsets"));
2087 }
2088 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::InjectSourceOffsets)
2089;
2090 }
2091 }
2092 }
2093 Ok(BarrierMutation {
2094 mutation: mutation__,
2095 })
2096 }
2097 }
2098 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2099 }
2100}
2101impl serde::Serialize for BarrierRecvNode {
2102 #[allow(deprecated)]
2103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2104 where
2105 S: serde::Serializer,
2106 {
2107 use serde::ser::SerializeStruct;
2108 let len = 0;
2109 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2110 struct_ser.end()
2111 }
2112}
2113impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2114 #[allow(deprecated)]
2115 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2116 where
2117 D: serde::Deserializer<'de>,
2118 {
2119 const FIELDS: &[&str] = &[
2120 ];
2121
2122 #[allow(clippy::enum_variant_names)]
2123 enum GeneratedField {
2124 }
2125 impl<'de> serde::Deserialize<'de> for GeneratedField {
2126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2127 where
2128 D: serde::Deserializer<'de>,
2129 {
2130 struct GeneratedVisitor;
2131
2132 impl serde::de::Visitor<'_> for GeneratedVisitor {
2133 type Value = GeneratedField;
2134
2135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2136 write!(formatter, "expected one of: {:?}", &FIELDS)
2137 }
2138
2139 #[allow(unused_variables)]
2140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2141 where
2142 E: serde::de::Error,
2143 {
2144 Err(serde::de::Error::unknown_field(value, FIELDS))
2145 }
2146 }
2147 deserializer.deserialize_identifier(GeneratedVisitor)
2148 }
2149 }
2150 struct GeneratedVisitor;
2151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2152 type Value = BarrierRecvNode;
2153
2154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2155 formatter.write_str("struct stream_plan.BarrierRecvNode")
2156 }
2157
2158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2159 where
2160 V: serde::de::MapAccess<'de>,
2161 {
2162 while map_.next_key::<GeneratedField>()?.is_some() {
2163 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2164 }
2165 Ok(BarrierRecvNode {
2166 })
2167 }
2168 }
2169 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2170 }
2171}
2172impl serde::Serialize for BatchPlanNode {
2173 #[allow(deprecated)]
2174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2175 where
2176 S: serde::Serializer,
2177 {
2178 use serde::ser::SerializeStruct;
2179 let mut len = 0;
2180 if self.table_desc.is_some() {
2181 len += 1;
2182 }
2183 if !self.column_ids.is_empty() {
2184 len += 1;
2185 }
2186 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2187 if let Some(v) = self.table_desc.as_ref() {
2188 struct_ser.serialize_field("tableDesc", v)?;
2189 }
2190 if !self.column_ids.is_empty() {
2191 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2192 }
2193 struct_ser.end()
2194 }
2195}
2196impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2197 #[allow(deprecated)]
2198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2199 where
2200 D: serde::Deserializer<'de>,
2201 {
2202 const FIELDS: &[&str] = &[
2203 "table_desc",
2204 "tableDesc",
2205 "column_ids",
2206 "columnIds",
2207 ];
2208
2209 #[allow(clippy::enum_variant_names)]
2210 enum GeneratedField {
2211 TableDesc,
2212 ColumnIds,
2213 }
2214 impl<'de> serde::Deserialize<'de> for GeneratedField {
2215 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2216 where
2217 D: serde::Deserializer<'de>,
2218 {
2219 struct GeneratedVisitor;
2220
2221 impl serde::de::Visitor<'_> for GeneratedVisitor {
2222 type Value = GeneratedField;
2223
2224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2225 write!(formatter, "expected one of: {:?}", &FIELDS)
2226 }
2227
2228 #[allow(unused_variables)]
2229 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2230 where
2231 E: serde::de::Error,
2232 {
2233 match value {
2234 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2235 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2236 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2237 }
2238 }
2239 }
2240 deserializer.deserialize_identifier(GeneratedVisitor)
2241 }
2242 }
2243 struct GeneratedVisitor;
2244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2245 type Value = BatchPlanNode;
2246
2247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2248 formatter.write_str("struct stream_plan.BatchPlanNode")
2249 }
2250
2251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2252 where
2253 V: serde::de::MapAccess<'de>,
2254 {
2255 let mut table_desc__ = None;
2256 let mut column_ids__ = None;
2257 while let Some(k) = map_.next_key()? {
2258 match k {
2259 GeneratedField::TableDesc => {
2260 if table_desc__.is_some() {
2261 return Err(serde::de::Error::duplicate_field("tableDesc"));
2262 }
2263 table_desc__ = map_.next_value()?;
2264 }
2265 GeneratedField::ColumnIds => {
2266 if column_ids__.is_some() {
2267 return Err(serde::de::Error::duplicate_field("columnIds"));
2268 }
2269 column_ids__ =
2270 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2271 .into_iter().map(|x| x.0).collect())
2272 ;
2273 }
2274 }
2275 }
2276 Ok(BatchPlanNode {
2277 table_desc: table_desc__,
2278 column_ids: column_ids__.unwrap_or_default(),
2279 })
2280 }
2281 }
2282 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2283 }
2284}
2285impl serde::Serialize for CdcFilterNode {
2286 #[allow(deprecated)]
2287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2288 where
2289 S: serde::Serializer,
2290 {
2291 use serde::ser::SerializeStruct;
2292 let mut len = 0;
2293 if self.search_condition.is_some() {
2294 len += 1;
2295 }
2296 if self.upstream_source_id != 0 {
2297 len += 1;
2298 }
2299 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2300 if let Some(v) = self.search_condition.as_ref() {
2301 struct_ser.serialize_field("searchCondition", v)?;
2302 }
2303 if self.upstream_source_id != 0 {
2304 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2305 }
2306 struct_ser.end()
2307 }
2308}
2309impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2310 #[allow(deprecated)]
2311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2312 where
2313 D: serde::Deserializer<'de>,
2314 {
2315 const FIELDS: &[&str] = &[
2316 "search_condition",
2317 "searchCondition",
2318 "upstream_source_id",
2319 "upstreamSourceId",
2320 ];
2321
2322 #[allow(clippy::enum_variant_names)]
2323 enum GeneratedField {
2324 SearchCondition,
2325 UpstreamSourceId,
2326 }
2327 impl<'de> serde::Deserialize<'de> for GeneratedField {
2328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2329 where
2330 D: serde::Deserializer<'de>,
2331 {
2332 struct GeneratedVisitor;
2333
2334 impl serde::de::Visitor<'_> for GeneratedVisitor {
2335 type Value = GeneratedField;
2336
2337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2338 write!(formatter, "expected one of: {:?}", &FIELDS)
2339 }
2340
2341 #[allow(unused_variables)]
2342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2343 where
2344 E: serde::de::Error,
2345 {
2346 match value {
2347 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2348 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2350 }
2351 }
2352 }
2353 deserializer.deserialize_identifier(GeneratedVisitor)
2354 }
2355 }
2356 struct GeneratedVisitor;
2357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2358 type Value = CdcFilterNode;
2359
2360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2361 formatter.write_str("struct stream_plan.CdcFilterNode")
2362 }
2363
2364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2365 where
2366 V: serde::de::MapAccess<'de>,
2367 {
2368 let mut search_condition__ = None;
2369 let mut upstream_source_id__ = None;
2370 while let Some(k) = map_.next_key()? {
2371 match k {
2372 GeneratedField::SearchCondition => {
2373 if search_condition__.is_some() {
2374 return Err(serde::de::Error::duplicate_field("searchCondition"));
2375 }
2376 search_condition__ = map_.next_value()?;
2377 }
2378 GeneratedField::UpstreamSourceId => {
2379 if upstream_source_id__.is_some() {
2380 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2381 }
2382 upstream_source_id__ =
2383 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2384 ;
2385 }
2386 }
2387 }
2388 Ok(CdcFilterNode {
2389 search_condition: search_condition__,
2390 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2391 })
2392 }
2393 }
2394 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2395 }
2396}
2397impl serde::Serialize for ChangeLogNode {
2398 #[allow(deprecated)]
2399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2400 where
2401 S: serde::Serializer,
2402 {
2403 use serde::ser::SerializeStruct;
2404 let mut len = 0;
2405 if self.need_op {
2406 len += 1;
2407 }
2408 if !self.distribution_keys.is_empty() {
2409 len += 1;
2410 }
2411 if !self.stream_keys.is_empty() {
2412 len += 1;
2413 }
2414 if self.mode.is_some() {
2415 len += 1;
2416 }
2417 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2418 if self.need_op {
2419 struct_ser.serialize_field("needOp", &self.need_op)?;
2420 }
2421 if !self.distribution_keys.is_empty() {
2422 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2423 }
2424 if !self.stream_keys.is_empty() {
2425 struct_ser.serialize_field("streamKeys", &self.stream_keys)?;
2426 }
2427 if let Some(v) = self.mode.as_ref() {
2428 match v {
2429 change_log_node::Mode::Keyed(v) => {
2430 struct_ser.serialize_field("keyed", v)?;
2431 }
2432 }
2433 }
2434 struct_ser.end()
2435 }
2436}
2437impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2438 #[allow(deprecated)]
2439 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2440 where
2441 D: serde::Deserializer<'de>,
2442 {
2443 const FIELDS: &[&str] = &[
2444 "need_op",
2445 "needOp",
2446 "distribution_keys",
2447 "distributionKeys",
2448 "stream_keys",
2449 "streamKeys",
2450 "keyed",
2451 ];
2452
2453 #[allow(clippy::enum_variant_names)]
2454 enum GeneratedField {
2455 NeedOp,
2456 DistributionKeys,
2457 StreamKeys,
2458 Keyed,
2459 }
2460 impl<'de> serde::Deserialize<'de> for GeneratedField {
2461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2462 where
2463 D: serde::Deserializer<'de>,
2464 {
2465 struct GeneratedVisitor;
2466
2467 impl serde::de::Visitor<'_> for GeneratedVisitor {
2468 type Value = GeneratedField;
2469
2470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2471 write!(formatter, "expected one of: {:?}", &FIELDS)
2472 }
2473
2474 #[allow(unused_variables)]
2475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2476 where
2477 E: serde::de::Error,
2478 {
2479 match value {
2480 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2481 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2482 "streamKeys" | "stream_keys" => Ok(GeneratedField::StreamKeys),
2483 "keyed" => Ok(GeneratedField::Keyed),
2484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2485 }
2486 }
2487 }
2488 deserializer.deserialize_identifier(GeneratedVisitor)
2489 }
2490 }
2491 struct GeneratedVisitor;
2492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2493 type Value = ChangeLogNode;
2494
2495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2496 formatter.write_str("struct stream_plan.ChangeLogNode")
2497 }
2498
2499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2500 where
2501 V: serde::de::MapAccess<'de>,
2502 {
2503 let mut need_op__ = None;
2504 let mut distribution_keys__ = None;
2505 let mut stream_keys__ = None;
2506 let mut mode__ = None;
2507 while let Some(k) = map_.next_key()? {
2508 match k {
2509 GeneratedField::NeedOp => {
2510 if need_op__.is_some() {
2511 return Err(serde::de::Error::duplicate_field("needOp"));
2512 }
2513 need_op__ = Some(map_.next_value()?);
2514 }
2515 GeneratedField::DistributionKeys => {
2516 if distribution_keys__.is_some() {
2517 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2518 }
2519 distribution_keys__ =
2520 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2521 .into_iter().map(|x| x.0).collect())
2522 ;
2523 }
2524 GeneratedField::StreamKeys => {
2525 if stream_keys__.is_some() {
2526 return Err(serde::de::Error::duplicate_field("streamKeys"));
2527 }
2528 stream_keys__ =
2529 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2530 .into_iter().map(|x| x.0).collect())
2531 ;
2532 }
2533 GeneratedField::Keyed => {
2534 if mode__.is_some() {
2535 return Err(serde::de::Error::duplicate_field("keyed"));
2536 }
2537 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(change_log_node::Mode::Keyed)
2538;
2539 }
2540 }
2541 }
2542 Ok(ChangeLogNode {
2543 need_op: need_op__.unwrap_or_default(),
2544 distribution_keys: distribution_keys__.unwrap_or_default(),
2545 stream_keys: stream_keys__.unwrap_or_default(),
2546 mode: mode__,
2547 })
2548 }
2549 }
2550 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2551 }
2552}
2553impl serde::Serialize for change_log_node::Keyed {
2554 #[allow(deprecated)]
2555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2556 where
2557 S: serde::Serializer,
2558 {
2559 use serde::ser::SerializeStruct;
2560 let mut len = 0;
2561 if !self.additional_key_columns.is_empty() {
2562 len += 1;
2563 }
2564 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode.Keyed", len)?;
2565 if !self.additional_key_columns.is_empty() {
2566 struct_ser.serialize_field("additionalKeyColumns", &self.additional_key_columns)?;
2567 }
2568 struct_ser.end()
2569 }
2570}
2571impl<'de> serde::Deserialize<'de> for change_log_node::Keyed {
2572 #[allow(deprecated)]
2573 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2574 where
2575 D: serde::Deserializer<'de>,
2576 {
2577 const FIELDS: &[&str] = &[
2578 "additional_key_columns",
2579 "additionalKeyColumns",
2580 ];
2581
2582 #[allow(clippy::enum_variant_names)]
2583 enum GeneratedField {
2584 AdditionalKeyColumns,
2585 }
2586 impl<'de> serde::Deserialize<'de> for GeneratedField {
2587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2588 where
2589 D: serde::Deserializer<'de>,
2590 {
2591 struct GeneratedVisitor;
2592
2593 impl serde::de::Visitor<'_> for GeneratedVisitor {
2594 type Value = GeneratedField;
2595
2596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2597 write!(formatter, "expected one of: {:?}", &FIELDS)
2598 }
2599
2600 #[allow(unused_variables)]
2601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2602 where
2603 E: serde::de::Error,
2604 {
2605 match value {
2606 "additionalKeyColumns" | "additional_key_columns" => Ok(GeneratedField::AdditionalKeyColumns),
2607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2608 }
2609 }
2610 }
2611 deserializer.deserialize_identifier(GeneratedVisitor)
2612 }
2613 }
2614 struct GeneratedVisitor;
2615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2616 type Value = change_log_node::Keyed;
2617
2618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2619 formatter.write_str("struct stream_plan.ChangeLogNode.Keyed")
2620 }
2621
2622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<change_log_node::Keyed, V::Error>
2623 where
2624 V: serde::de::MapAccess<'de>,
2625 {
2626 let mut additional_key_columns__ = None;
2627 while let Some(k) = map_.next_key()? {
2628 match k {
2629 GeneratedField::AdditionalKeyColumns => {
2630 if additional_key_columns__.is_some() {
2631 return Err(serde::de::Error::duplicate_field("additionalKeyColumns"));
2632 }
2633 additional_key_columns__ =
2634 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2635 .into_iter().map(|x| x.0).collect())
2636 ;
2637 }
2638 }
2639 }
2640 Ok(change_log_node::Keyed {
2641 additional_key_columns: additional_key_columns__.unwrap_or_default(),
2642 })
2643 }
2644 }
2645 deserializer.deserialize_struct("stream_plan.ChangeLogNode.Keyed", FIELDS, GeneratedVisitor)
2646 }
2647}
2648impl serde::Serialize for Columns {
2649 #[allow(deprecated)]
2650 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2651 where
2652 S: serde::Serializer,
2653 {
2654 use serde::ser::SerializeStruct;
2655 let mut len = 0;
2656 if !self.columns.is_empty() {
2657 len += 1;
2658 }
2659 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2660 if !self.columns.is_empty() {
2661 struct_ser.serialize_field("columns", &self.columns)?;
2662 }
2663 struct_ser.end()
2664 }
2665}
2666impl<'de> serde::Deserialize<'de> for Columns {
2667 #[allow(deprecated)]
2668 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2669 where
2670 D: serde::Deserializer<'de>,
2671 {
2672 const FIELDS: &[&str] = &[
2673 "columns",
2674 ];
2675
2676 #[allow(clippy::enum_variant_names)]
2677 enum GeneratedField {
2678 Columns,
2679 }
2680 impl<'de> serde::Deserialize<'de> for GeneratedField {
2681 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2682 where
2683 D: serde::Deserializer<'de>,
2684 {
2685 struct GeneratedVisitor;
2686
2687 impl serde::de::Visitor<'_> for GeneratedVisitor {
2688 type Value = GeneratedField;
2689
2690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2691 write!(formatter, "expected one of: {:?}", &FIELDS)
2692 }
2693
2694 #[allow(unused_variables)]
2695 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2696 where
2697 E: serde::de::Error,
2698 {
2699 match value {
2700 "columns" => Ok(GeneratedField::Columns),
2701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2702 }
2703 }
2704 }
2705 deserializer.deserialize_identifier(GeneratedVisitor)
2706 }
2707 }
2708 struct GeneratedVisitor;
2709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2710 type Value = Columns;
2711
2712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2713 formatter.write_str("struct stream_plan.Columns")
2714 }
2715
2716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2717 where
2718 V: serde::de::MapAccess<'de>,
2719 {
2720 let mut columns__ = None;
2721 while let Some(k) = map_.next_key()? {
2722 match k {
2723 GeneratedField::Columns => {
2724 if columns__.is_some() {
2725 return Err(serde::de::Error::duplicate_field("columns"));
2726 }
2727 columns__ = Some(map_.next_value()?);
2728 }
2729 }
2730 }
2731 Ok(Columns {
2732 columns: columns__.unwrap_or_default(),
2733 })
2734 }
2735 }
2736 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2737 }
2738}
2739impl serde::Serialize for CompactionResolverNode {
2740 #[allow(deprecated)]
2741 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2742 where
2743 S: serde::Serializer,
2744 {
2745 use serde::ser::SerializeStruct;
2746 let mut len = 0;
2747 if self.sink_id != 0 {
2748 len += 1;
2749 }
2750 if !self.properties.is_empty() {
2751 len += 1;
2752 }
2753 if !self.secret_refs.is_empty() {
2754 len += 1;
2755 }
2756 if !self.pk_columns.is_empty() {
2757 len += 1;
2758 }
2759 let mut struct_ser = serializer.serialize_struct("stream_plan.CompactionResolverNode", len)?;
2760 if self.sink_id != 0 {
2761 struct_ser.serialize_field("sinkId", &self.sink_id)?;
2762 }
2763 if !self.properties.is_empty() {
2764 struct_ser.serialize_field("properties", &self.properties)?;
2765 }
2766 if !self.secret_refs.is_empty() {
2767 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
2768 }
2769 if !self.pk_columns.is_empty() {
2770 struct_ser.serialize_field("pkColumns", &self.pk_columns)?;
2771 }
2772 struct_ser.end()
2773 }
2774}
2775impl<'de> serde::Deserialize<'de> for CompactionResolverNode {
2776 #[allow(deprecated)]
2777 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2778 where
2779 D: serde::Deserializer<'de>,
2780 {
2781 const FIELDS: &[&str] = &[
2782 "sink_id",
2783 "sinkId",
2784 "properties",
2785 "secret_refs",
2786 "secretRefs",
2787 "pk_columns",
2788 "pkColumns",
2789 ];
2790
2791 #[allow(clippy::enum_variant_names)]
2792 enum GeneratedField {
2793 SinkId,
2794 Properties,
2795 SecretRefs,
2796 PkColumns,
2797 }
2798 impl<'de> serde::Deserialize<'de> for GeneratedField {
2799 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2800 where
2801 D: serde::Deserializer<'de>,
2802 {
2803 struct GeneratedVisitor;
2804
2805 impl serde::de::Visitor<'_> for GeneratedVisitor {
2806 type Value = GeneratedField;
2807
2808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2809 write!(formatter, "expected one of: {:?}", &FIELDS)
2810 }
2811
2812 #[allow(unused_variables)]
2813 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2814 where
2815 E: serde::de::Error,
2816 {
2817 match value {
2818 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2819 "properties" => Ok(GeneratedField::Properties),
2820 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
2821 "pkColumns" | "pk_columns" => Ok(GeneratedField::PkColumns),
2822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2823 }
2824 }
2825 }
2826 deserializer.deserialize_identifier(GeneratedVisitor)
2827 }
2828 }
2829 struct GeneratedVisitor;
2830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2831 type Value = CompactionResolverNode;
2832
2833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2834 formatter.write_str("struct stream_plan.CompactionResolverNode")
2835 }
2836
2837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionResolverNode, V::Error>
2838 where
2839 V: serde::de::MapAccess<'de>,
2840 {
2841 let mut sink_id__ = None;
2842 let mut properties__ = None;
2843 let mut secret_refs__ = None;
2844 let mut pk_columns__ = None;
2845 while let Some(k) = map_.next_key()? {
2846 match k {
2847 GeneratedField::SinkId => {
2848 if sink_id__.is_some() {
2849 return Err(serde::de::Error::duplicate_field("sinkId"));
2850 }
2851 sink_id__ =
2852 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2853 ;
2854 }
2855 GeneratedField::Properties => {
2856 if properties__.is_some() {
2857 return Err(serde::de::Error::duplicate_field("properties"));
2858 }
2859 properties__ = Some(
2860 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2861 );
2862 }
2863 GeneratedField::SecretRefs => {
2864 if secret_refs__.is_some() {
2865 return Err(serde::de::Error::duplicate_field("secretRefs"));
2866 }
2867 secret_refs__ = Some(
2868 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2869 );
2870 }
2871 GeneratedField::PkColumns => {
2872 if pk_columns__.is_some() {
2873 return Err(serde::de::Error::duplicate_field("pkColumns"));
2874 }
2875 pk_columns__ = Some(map_.next_value()?);
2876 }
2877 }
2878 }
2879 Ok(CompactionResolverNode {
2880 sink_id: sink_id__.unwrap_or_default(),
2881 properties: properties__.unwrap_or_default(),
2882 secret_refs: secret_refs__.unwrap_or_default(),
2883 pk_columns: pk_columns__.unwrap_or_default(),
2884 })
2885 }
2886 }
2887 deserializer.deserialize_struct("stream_plan.CompactionResolverNode", FIELDS, GeneratedVisitor)
2888 }
2889}
2890impl serde::Serialize for compaction_resolver_node::PkColumn {
2891 #[allow(deprecated)]
2892 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2893 where
2894 S: serde::Serializer,
2895 {
2896 use serde::ser::SerializeStruct;
2897 let mut len = 0;
2898 if self.data_file_index != 0 {
2899 len += 1;
2900 }
2901 if self.column_desc.is_some() {
2902 len += 1;
2903 }
2904 let mut struct_ser = serializer.serialize_struct("stream_plan.CompactionResolverNode.PkColumn", len)?;
2905 if self.data_file_index != 0 {
2906 struct_ser.serialize_field("dataFileIndex", &self.data_file_index)?;
2907 }
2908 if let Some(v) = self.column_desc.as_ref() {
2909 struct_ser.serialize_field("columnDesc", v)?;
2910 }
2911 struct_ser.end()
2912 }
2913}
2914impl<'de> serde::Deserialize<'de> for compaction_resolver_node::PkColumn {
2915 #[allow(deprecated)]
2916 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2917 where
2918 D: serde::Deserializer<'de>,
2919 {
2920 const FIELDS: &[&str] = &[
2921 "data_file_index",
2922 "dataFileIndex",
2923 "column_desc",
2924 "columnDesc",
2925 ];
2926
2927 #[allow(clippy::enum_variant_names)]
2928 enum GeneratedField {
2929 DataFileIndex,
2930 ColumnDesc,
2931 }
2932 impl<'de> serde::Deserialize<'de> for GeneratedField {
2933 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2934 where
2935 D: serde::Deserializer<'de>,
2936 {
2937 struct GeneratedVisitor;
2938
2939 impl serde::de::Visitor<'_> for GeneratedVisitor {
2940 type Value = GeneratedField;
2941
2942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2943 write!(formatter, "expected one of: {:?}", &FIELDS)
2944 }
2945
2946 #[allow(unused_variables)]
2947 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2948 where
2949 E: serde::de::Error,
2950 {
2951 match value {
2952 "dataFileIndex" | "data_file_index" => Ok(GeneratedField::DataFileIndex),
2953 "columnDesc" | "column_desc" => Ok(GeneratedField::ColumnDesc),
2954 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2955 }
2956 }
2957 }
2958 deserializer.deserialize_identifier(GeneratedVisitor)
2959 }
2960 }
2961 struct GeneratedVisitor;
2962 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2963 type Value = compaction_resolver_node::PkColumn;
2964
2965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2966 formatter.write_str("struct stream_plan.CompactionResolverNode.PkColumn")
2967 }
2968
2969 fn visit_map<V>(self, mut map_: V) -> std::result::Result<compaction_resolver_node::PkColumn, V::Error>
2970 where
2971 V: serde::de::MapAccess<'de>,
2972 {
2973 let mut data_file_index__ = None;
2974 let mut column_desc__ = None;
2975 while let Some(k) = map_.next_key()? {
2976 match k {
2977 GeneratedField::DataFileIndex => {
2978 if data_file_index__.is_some() {
2979 return Err(serde::de::Error::duplicate_field("dataFileIndex"));
2980 }
2981 data_file_index__ =
2982 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2983 ;
2984 }
2985 GeneratedField::ColumnDesc => {
2986 if column_desc__.is_some() {
2987 return Err(serde::de::Error::duplicate_field("columnDesc"));
2988 }
2989 column_desc__ = map_.next_value()?;
2990 }
2991 }
2992 }
2993 Ok(compaction_resolver_node::PkColumn {
2994 data_file_index: data_file_index__.unwrap_or_default(),
2995 column_desc: column_desc__,
2996 })
2997 }
2998 }
2999 deserializer.deserialize_struct("stream_plan.CompactionResolverNode.PkColumn", FIELDS, GeneratedVisitor)
3000 }
3001}
3002impl serde::Serialize for ConnectorPropsChangeMutation {
3003 #[allow(deprecated)]
3004 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3005 where
3006 S: serde::Serializer,
3007 {
3008 use serde::ser::SerializeStruct;
3009 let mut len = 0;
3010 if !self.connector_props_infos.is_empty() {
3011 len += 1;
3012 }
3013 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
3014 if !self.connector_props_infos.is_empty() {
3015 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
3016 }
3017 struct_ser.end()
3018 }
3019}
3020impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
3021 #[allow(deprecated)]
3022 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3023 where
3024 D: serde::Deserializer<'de>,
3025 {
3026 const FIELDS: &[&str] = &[
3027 "connector_props_infos",
3028 "connectorPropsInfos",
3029 ];
3030
3031 #[allow(clippy::enum_variant_names)]
3032 enum GeneratedField {
3033 ConnectorPropsInfos,
3034 }
3035 impl<'de> serde::Deserialize<'de> for GeneratedField {
3036 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3037 where
3038 D: serde::Deserializer<'de>,
3039 {
3040 struct GeneratedVisitor;
3041
3042 impl serde::de::Visitor<'_> for GeneratedVisitor {
3043 type Value = GeneratedField;
3044
3045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3046 write!(formatter, "expected one of: {:?}", &FIELDS)
3047 }
3048
3049 #[allow(unused_variables)]
3050 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3051 where
3052 E: serde::de::Error,
3053 {
3054 match value {
3055 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
3056 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3057 }
3058 }
3059 }
3060 deserializer.deserialize_identifier(GeneratedVisitor)
3061 }
3062 }
3063 struct GeneratedVisitor;
3064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3065 type Value = ConnectorPropsChangeMutation;
3066
3067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3068 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
3069 }
3070
3071 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
3072 where
3073 V: serde::de::MapAccess<'de>,
3074 {
3075 let mut connector_props_infos__ = None;
3076 while let Some(k) = map_.next_key()? {
3077 match k {
3078 GeneratedField::ConnectorPropsInfos => {
3079 if connector_props_infos__.is_some() {
3080 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
3081 }
3082 connector_props_infos__ = Some(
3083 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
3084 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
3085 );
3086 }
3087 }
3088 }
3089 Ok(ConnectorPropsChangeMutation {
3090 connector_props_infos: connector_props_infos__.unwrap_or_default(),
3091 })
3092 }
3093 }
3094 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
3095 }
3096}
3097impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
3098 #[allow(deprecated)]
3099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3100 where
3101 S: serde::Serializer,
3102 {
3103 use serde::ser::SerializeStruct;
3104 let mut len = 0;
3105 if !self.connector_props_info.is_empty() {
3106 len += 1;
3107 }
3108 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
3109 if !self.connector_props_info.is_empty() {
3110 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
3111 }
3112 struct_ser.end()
3113 }
3114}
3115impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
3116 #[allow(deprecated)]
3117 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3118 where
3119 D: serde::Deserializer<'de>,
3120 {
3121 const FIELDS: &[&str] = &[
3122 "connector_props_info",
3123 "connectorPropsInfo",
3124 ];
3125
3126 #[allow(clippy::enum_variant_names)]
3127 enum GeneratedField {
3128 ConnectorPropsInfo,
3129 }
3130 impl<'de> serde::Deserialize<'de> for GeneratedField {
3131 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3132 where
3133 D: serde::Deserializer<'de>,
3134 {
3135 struct GeneratedVisitor;
3136
3137 impl serde::de::Visitor<'_> for GeneratedVisitor {
3138 type Value = GeneratedField;
3139
3140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3141 write!(formatter, "expected one of: {:?}", &FIELDS)
3142 }
3143
3144 #[allow(unused_variables)]
3145 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3146 where
3147 E: serde::de::Error,
3148 {
3149 match value {
3150 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
3151 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3152 }
3153 }
3154 }
3155 deserializer.deserialize_identifier(GeneratedVisitor)
3156 }
3157 }
3158 struct GeneratedVisitor;
3159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3160 type Value = connector_props_change_mutation::ConnectorPropsInfo;
3161
3162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3163 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
3164 }
3165
3166 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
3167 where
3168 V: serde::de::MapAccess<'de>,
3169 {
3170 let mut connector_props_info__ = None;
3171 while let Some(k) = map_.next_key()? {
3172 match k {
3173 GeneratedField::ConnectorPropsInfo => {
3174 if connector_props_info__.is_some() {
3175 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
3176 }
3177 connector_props_info__ = Some(
3178 map_.next_value::<std::collections::HashMap<_, _>>()?
3179 );
3180 }
3181 }
3182 }
3183 Ok(connector_props_change_mutation::ConnectorPropsInfo {
3184 connector_props_info: connector_props_info__.unwrap_or_default(),
3185 })
3186 }
3187 }
3188 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
3189 }
3190}
3191impl serde::Serialize for DedupNode {
3192 #[allow(deprecated)]
3193 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3194 where
3195 S: serde::Serializer,
3196 {
3197 use serde::ser::SerializeStruct;
3198 let mut len = 0;
3199 if self.state_table.is_some() {
3200 len += 1;
3201 }
3202 if !self.dedup_column_indices.is_empty() {
3203 len += 1;
3204 }
3205 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
3206 if let Some(v) = self.state_table.as_ref() {
3207 struct_ser.serialize_field("stateTable", v)?;
3208 }
3209 if !self.dedup_column_indices.is_empty() {
3210 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
3211 }
3212 struct_ser.end()
3213 }
3214}
3215impl<'de> serde::Deserialize<'de> for DedupNode {
3216 #[allow(deprecated)]
3217 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3218 where
3219 D: serde::Deserializer<'de>,
3220 {
3221 const FIELDS: &[&str] = &[
3222 "state_table",
3223 "stateTable",
3224 "dedup_column_indices",
3225 "dedupColumnIndices",
3226 ];
3227
3228 #[allow(clippy::enum_variant_names)]
3229 enum GeneratedField {
3230 StateTable,
3231 DedupColumnIndices,
3232 }
3233 impl<'de> serde::Deserialize<'de> for GeneratedField {
3234 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3235 where
3236 D: serde::Deserializer<'de>,
3237 {
3238 struct GeneratedVisitor;
3239
3240 impl serde::de::Visitor<'_> for GeneratedVisitor {
3241 type Value = GeneratedField;
3242
3243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3244 write!(formatter, "expected one of: {:?}", &FIELDS)
3245 }
3246
3247 #[allow(unused_variables)]
3248 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3249 where
3250 E: serde::de::Error,
3251 {
3252 match value {
3253 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
3254 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
3255 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3256 }
3257 }
3258 }
3259 deserializer.deserialize_identifier(GeneratedVisitor)
3260 }
3261 }
3262 struct GeneratedVisitor;
3263 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3264 type Value = DedupNode;
3265
3266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3267 formatter.write_str("struct stream_plan.DedupNode")
3268 }
3269
3270 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
3271 where
3272 V: serde::de::MapAccess<'de>,
3273 {
3274 let mut state_table__ = None;
3275 let mut dedup_column_indices__ = None;
3276 while let Some(k) = map_.next_key()? {
3277 match k {
3278 GeneratedField::StateTable => {
3279 if state_table__.is_some() {
3280 return Err(serde::de::Error::duplicate_field("stateTable"));
3281 }
3282 state_table__ = map_.next_value()?;
3283 }
3284 GeneratedField::DedupColumnIndices => {
3285 if dedup_column_indices__.is_some() {
3286 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
3287 }
3288 dedup_column_indices__ =
3289 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3290 .into_iter().map(|x| x.0).collect())
3291 ;
3292 }
3293 }
3294 }
3295 Ok(DedupNode {
3296 state_table: state_table__,
3297 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
3298 })
3299 }
3300 }
3301 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
3302 }
3303}
3304impl serde::Serialize for DeltaExpression {
3305 #[allow(deprecated)]
3306 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3307 where
3308 S: serde::Serializer,
3309 {
3310 use serde::ser::SerializeStruct;
3311 let mut len = 0;
3312 if self.delta_type != 0 {
3313 len += 1;
3314 }
3315 if self.delta.is_some() {
3316 len += 1;
3317 }
3318 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
3319 if self.delta_type != 0 {
3320 let v = super::expr::expr_node::Type::try_from(self.delta_type)
3321 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
3322 struct_ser.serialize_field("deltaType", &v)?;
3323 }
3324 if let Some(v) = self.delta.as_ref() {
3325 struct_ser.serialize_field("delta", v)?;
3326 }
3327 struct_ser.end()
3328 }
3329}
3330impl<'de> serde::Deserialize<'de> for DeltaExpression {
3331 #[allow(deprecated)]
3332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3333 where
3334 D: serde::Deserializer<'de>,
3335 {
3336 const FIELDS: &[&str] = &[
3337 "delta_type",
3338 "deltaType",
3339 "delta",
3340 ];
3341
3342 #[allow(clippy::enum_variant_names)]
3343 enum GeneratedField {
3344 DeltaType,
3345 Delta,
3346 }
3347 impl<'de> serde::Deserialize<'de> for GeneratedField {
3348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3349 where
3350 D: serde::Deserializer<'de>,
3351 {
3352 struct GeneratedVisitor;
3353
3354 impl serde::de::Visitor<'_> for GeneratedVisitor {
3355 type Value = GeneratedField;
3356
3357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3358 write!(formatter, "expected one of: {:?}", &FIELDS)
3359 }
3360
3361 #[allow(unused_variables)]
3362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3363 where
3364 E: serde::de::Error,
3365 {
3366 match value {
3367 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
3368 "delta" => Ok(GeneratedField::Delta),
3369 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3370 }
3371 }
3372 }
3373 deserializer.deserialize_identifier(GeneratedVisitor)
3374 }
3375 }
3376 struct GeneratedVisitor;
3377 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3378 type Value = DeltaExpression;
3379
3380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3381 formatter.write_str("struct stream_plan.DeltaExpression")
3382 }
3383
3384 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
3385 where
3386 V: serde::de::MapAccess<'de>,
3387 {
3388 let mut delta_type__ = None;
3389 let mut delta__ = None;
3390 while let Some(k) = map_.next_key()? {
3391 match k {
3392 GeneratedField::DeltaType => {
3393 if delta_type__.is_some() {
3394 return Err(serde::de::Error::duplicate_field("deltaType"));
3395 }
3396 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
3397 }
3398 GeneratedField::Delta => {
3399 if delta__.is_some() {
3400 return Err(serde::de::Error::duplicate_field("delta"));
3401 }
3402 delta__ = map_.next_value()?;
3403 }
3404 }
3405 }
3406 Ok(DeltaExpression {
3407 delta_type: delta_type__.unwrap_or_default(),
3408 delta: delta__,
3409 })
3410 }
3411 }
3412 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
3413 }
3414}
3415impl serde::Serialize for DeltaIndexJoinNode {
3416 #[allow(deprecated)]
3417 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3418 where
3419 S: serde::Serializer,
3420 {
3421 use serde::ser::SerializeStruct;
3422 let mut len = 0;
3423 if self.join_type != 0 {
3424 len += 1;
3425 }
3426 if !self.left_key.is_empty() {
3427 len += 1;
3428 }
3429 if !self.right_key.is_empty() {
3430 len += 1;
3431 }
3432 if self.condition.is_some() {
3433 len += 1;
3434 }
3435 if self.left_table_id != 0 {
3436 len += 1;
3437 }
3438 if self.right_table_id != 0 {
3439 len += 1;
3440 }
3441 if self.left_info.is_some() {
3442 len += 1;
3443 }
3444 if self.right_info.is_some() {
3445 len += 1;
3446 }
3447 if !self.output_indices.is_empty() {
3448 len += 1;
3449 }
3450 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
3451 if self.join_type != 0 {
3452 let v = super::plan_common::JoinType::try_from(self.join_type)
3453 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3454 struct_ser.serialize_field("joinType", &v)?;
3455 }
3456 if !self.left_key.is_empty() {
3457 struct_ser.serialize_field("leftKey", &self.left_key)?;
3458 }
3459 if !self.right_key.is_empty() {
3460 struct_ser.serialize_field("rightKey", &self.right_key)?;
3461 }
3462 if let Some(v) = self.condition.as_ref() {
3463 struct_ser.serialize_field("condition", v)?;
3464 }
3465 if self.left_table_id != 0 {
3466 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3467 }
3468 if self.right_table_id != 0 {
3469 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3470 }
3471 if let Some(v) = self.left_info.as_ref() {
3472 struct_ser.serialize_field("leftInfo", v)?;
3473 }
3474 if let Some(v) = self.right_info.as_ref() {
3475 struct_ser.serialize_field("rightInfo", v)?;
3476 }
3477 if !self.output_indices.is_empty() {
3478 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3479 }
3480 struct_ser.end()
3481 }
3482}
3483impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3484 #[allow(deprecated)]
3485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3486 where
3487 D: serde::Deserializer<'de>,
3488 {
3489 const FIELDS: &[&str] = &[
3490 "join_type",
3491 "joinType",
3492 "left_key",
3493 "leftKey",
3494 "right_key",
3495 "rightKey",
3496 "condition",
3497 "left_table_id",
3498 "leftTableId",
3499 "right_table_id",
3500 "rightTableId",
3501 "left_info",
3502 "leftInfo",
3503 "right_info",
3504 "rightInfo",
3505 "output_indices",
3506 "outputIndices",
3507 ];
3508
3509 #[allow(clippy::enum_variant_names)]
3510 enum GeneratedField {
3511 JoinType,
3512 LeftKey,
3513 RightKey,
3514 Condition,
3515 LeftTableId,
3516 RightTableId,
3517 LeftInfo,
3518 RightInfo,
3519 OutputIndices,
3520 }
3521 impl<'de> serde::Deserialize<'de> for GeneratedField {
3522 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3523 where
3524 D: serde::Deserializer<'de>,
3525 {
3526 struct GeneratedVisitor;
3527
3528 impl serde::de::Visitor<'_> for GeneratedVisitor {
3529 type Value = GeneratedField;
3530
3531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3532 write!(formatter, "expected one of: {:?}", &FIELDS)
3533 }
3534
3535 #[allow(unused_variables)]
3536 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3537 where
3538 E: serde::de::Error,
3539 {
3540 match value {
3541 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3542 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3543 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3544 "condition" => Ok(GeneratedField::Condition),
3545 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3546 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3547 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3548 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3549 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3551 }
3552 }
3553 }
3554 deserializer.deserialize_identifier(GeneratedVisitor)
3555 }
3556 }
3557 struct GeneratedVisitor;
3558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3559 type Value = DeltaIndexJoinNode;
3560
3561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3562 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3563 }
3564
3565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3566 where
3567 V: serde::de::MapAccess<'de>,
3568 {
3569 let mut join_type__ = None;
3570 let mut left_key__ = None;
3571 let mut right_key__ = None;
3572 let mut condition__ = None;
3573 let mut left_table_id__ = None;
3574 let mut right_table_id__ = None;
3575 let mut left_info__ = None;
3576 let mut right_info__ = None;
3577 let mut output_indices__ = None;
3578 while let Some(k) = map_.next_key()? {
3579 match k {
3580 GeneratedField::JoinType => {
3581 if join_type__.is_some() {
3582 return Err(serde::de::Error::duplicate_field("joinType"));
3583 }
3584 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3585 }
3586 GeneratedField::LeftKey => {
3587 if left_key__.is_some() {
3588 return Err(serde::de::Error::duplicate_field("leftKey"));
3589 }
3590 left_key__ =
3591 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3592 .into_iter().map(|x| x.0).collect())
3593 ;
3594 }
3595 GeneratedField::RightKey => {
3596 if right_key__.is_some() {
3597 return Err(serde::de::Error::duplicate_field("rightKey"));
3598 }
3599 right_key__ =
3600 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3601 .into_iter().map(|x| x.0).collect())
3602 ;
3603 }
3604 GeneratedField::Condition => {
3605 if condition__.is_some() {
3606 return Err(serde::de::Error::duplicate_field("condition"));
3607 }
3608 condition__ = map_.next_value()?;
3609 }
3610 GeneratedField::LeftTableId => {
3611 if left_table_id__.is_some() {
3612 return Err(serde::de::Error::duplicate_field("leftTableId"));
3613 }
3614 left_table_id__ =
3615 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3616 ;
3617 }
3618 GeneratedField::RightTableId => {
3619 if right_table_id__.is_some() {
3620 return Err(serde::de::Error::duplicate_field("rightTableId"));
3621 }
3622 right_table_id__ =
3623 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3624 ;
3625 }
3626 GeneratedField::LeftInfo => {
3627 if left_info__.is_some() {
3628 return Err(serde::de::Error::duplicate_field("leftInfo"));
3629 }
3630 left_info__ = map_.next_value()?;
3631 }
3632 GeneratedField::RightInfo => {
3633 if right_info__.is_some() {
3634 return Err(serde::de::Error::duplicate_field("rightInfo"));
3635 }
3636 right_info__ = map_.next_value()?;
3637 }
3638 GeneratedField::OutputIndices => {
3639 if output_indices__.is_some() {
3640 return Err(serde::de::Error::duplicate_field("outputIndices"));
3641 }
3642 output_indices__ =
3643 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3644 .into_iter().map(|x| x.0).collect())
3645 ;
3646 }
3647 }
3648 }
3649 Ok(DeltaIndexJoinNode {
3650 join_type: join_type__.unwrap_or_default(),
3651 left_key: left_key__.unwrap_or_default(),
3652 right_key: right_key__.unwrap_or_default(),
3653 condition: condition__,
3654 left_table_id: left_table_id__.unwrap_or_default(),
3655 right_table_id: right_table_id__.unwrap_or_default(),
3656 left_info: left_info__,
3657 right_info: right_info__,
3658 output_indices: output_indices__.unwrap_or_default(),
3659 })
3660 }
3661 }
3662 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3663 }
3664}
3665impl serde::Serialize for DispatchOutputMapping {
3666 #[allow(deprecated)]
3667 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3668 where
3669 S: serde::Serializer,
3670 {
3671 use serde::ser::SerializeStruct;
3672 let mut len = 0;
3673 if !self.indices.is_empty() {
3674 len += 1;
3675 }
3676 if !self.types.is_empty() {
3677 len += 1;
3678 }
3679 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3680 if !self.indices.is_empty() {
3681 struct_ser.serialize_field("indices", &self.indices)?;
3682 }
3683 if !self.types.is_empty() {
3684 struct_ser.serialize_field("types", &self.types)?;
3685 }
3686 struct_ser.end()
3687 }
3688}
3689impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3690 #[allow(deprecated)]
3691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3692 where
3693 D: serde::Deserializer<'de>,
3694 {
3695 const FIELDS: &[&str] = &[
3696 "indices",
3697 "types",
3698 ];
3699
3700 #[allow(clippy::enum_variant_names)]
3701 enum GeneratedField {
3702 Indices,
3703 Types,
3704 }
3705 impl<'de> serde::Deserialize<'de> for GeneratedField {
3706 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3707 where
3708 D: serde::Deserializer<'de>,
3709 {
3710 struct GeneratedVisitor;
3711
3712 impl serde::de::Visitor<'_> for GeneratedVisitor {
3713 type Value = GeneratedField;
3714
3715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3716 write!(formatter, "expected one of: {:?}", &FIELDS)
3717 }
3718
3719 #[allow(unused_variables)]
3720 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3721 where
3722 E: serde::de::Error,
3723 {
3724 match value {
3725 "indices" => Ok(GeneratedField::Indices),
3726 "types" => Ok(GeneratedField::Types),
3727 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3728 }
3729 }
3730 }
3731 deserializer.deserialize_identifier(GeneratedVisitor)
3732 }
3733 }
3734 struct GeneratedVisitor;
3735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3736 type Value = DispatchOutputMapping;
3737
3738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3739 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3740 }
3741
3742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3743 where
3744 V: serde::de::MapAccess<'de>,
3745 {
3746 let mut indices__ = None;
3747 let mut types__ = None;
3748 while let Some(k) = map_.next_key()? {
3749 match k {
3750 GeneratedField::Indices => {
3751 if indices__.is_some() {
3752 return Err(serde::de::Error::duplicate_field("indices"));
3753 }
3754 indices__ =
3755 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3756 .into_iter().map(|x| x.0).collect())
3757 ;
3758 }
3759 GeneratedField::Types => {
3760 if types__.is_some() {
3761 return Err(serde::de::Error::duplicate_field("types"));
3762 }
3763 types__ = Some(map_.next_value()?);
3764 }
3765 }
3766 }
3767 Ok(DispatchOutputMapping {
3768 indices: indices__.unwrap_or_default(),
3769 types: types__.unwrap_or_default(),
3770 })
3771 }
3772 }
3773 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3774 }
3775}
3776impl serde::Serialize for dispatch_output_mapping::TypePair {
3777 #[allow(deprecated)]
3778 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3779 where
3780 S: serde::Serializer,
3781 {
3782 use serde::ser::SerializeStruct;
3783 let mut len = 0;
3784 if self.upstream.is_some() {
3785 len += 1;
3786 }
3787 if self.downstream.is_some() {
3788 len += 1;
3789 }
3790 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3791 if let Some(v) = self.upstream.as_ref() {
3792 struct_ser.serialize_field("upstream", v)?;
3793 }
3794 if let Some(v) = self.downstream.as_ref() {
3795 struct_ser.serialize_field("downstream", v)?;
3796 }
3797 struct_ser.end()
3798 }
3799}
3800impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3801 #[allow(deprecated)]
3802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3803 where
3804 D: serde::Deserializer<'de>,
3805 {
3806 const FIELDS: &[&str] = &[
3807 "upstream",
3808 "downstream",
3809 ];
3810
3811 #[allow(clippy::enum_variant_names)]
3812 enum GeneratedField {
3813 Upstream,
3814 Downstream,
3815 }
3816 impl<'de> serde::Deserialize<'de> for GeneratedField {
3817 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3818 where
3819 D: serde::Deserializer<'de>,
3820 {
3821 struct GeneratedVisitor;
3822
3823 impl serde::de::Visitor<'_> for GeneratedVisitor {
3824 type Value = GeneratedField;
3825
3826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3827 write!(formatter, "expected one of: {:?}", &FIELDS)
3828 }
3829
3830 #[allow(unused_variables)]
3831 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3832 where
3833 E: serde::de::Error,
3834 {
3835 match value {
3836 "upstream" => Ok(GeneratedField::Upstream),
3837 "downstream" => Ok(GeneratedField::Downstream),
3838 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3839 }
3840 }
3841 }
3842 deserializer.deserialize_identifier(GeneratedVisitor)
3843 }
3844 }
3845 struct GeneratedVisitor;
3846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3847 type Value = dispatch_output_mapping::TypePair;
3848
3849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3850 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3851 }
3852
3853 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3854 where
3855 V: serde::de::MapAccess<'de>,
3856 {
3857 let mut upstream__ = None;
3858 let mut downstream__ = None;
3859 while let Some(k) = map_.next_key()? {
3860 match k {
3861 GeneratedField::Upstream => {
3862 if upstream__.is_some() {
3863 return Err(serde::de::Error::duplicate_field("upstream"));
3864 }
3865 upstream__ = map_.next_value()?;
3866 }
3867 GeneratedField::Downstream => {
3868 if downstream__.is_some() {
3869 return Err(serde::de::Error::duplicate_field("downstream"));
3870 }
3871 downstream__ = map_.next_value()?;
3872 }
3873 }
3874 }
3875 Ok(dispatch_output_mapping::TypePair {
3876 upstream: upstream__,
3877 downstream: downstream__,
3878 })
3879 }
3880 }
3881 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3882 }
3883}
3884impl serde::Serialize for DispatchStrategy {
3885 #[allow(deprecated)]
3886 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3887 where
3888 S: serde::Serializer,
3889 {
3890 use serde::ser::SerializeStruct;
3891 let mut len = 0;
3892 if self.r#type != 0 {
3893 len += 1;
3894 }
3895 if !self.dist_key_indices.is_empty() {
3896 len += 1;
3897 }
3898 if self.output_mapping.is_some() {
3899 len += 1;
3900 }
3901 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3902 if self.r#type != 0 {
3903 let v = DispatcherType::try_from(self.r#type)
3904 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3905 struct_ser.serialize_field("type", &v)?;
3906 }
3907 if !self.dist_key_indices.is_empty() {
3908 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3909 }
3910 if let Some(v) = self.output_mapping.as_ref() {
3911 struct_ser.serialize_field("outputMapping", v)?;
3912 }
3913 struct_ser.end()
3914 }
3915}
3916impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3917 #[allow(deprecated)]
3918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3919 where
3920 D: serde::Deserializer<'de>,
3921 {
3922 const FIELDS: &[&str] = &[
3923 "type",
3924 "dist_key_indices",
3925 "distKeyIndices",
3926 "output_mapping",
3927 "outputMapping",
3928 ];
3929
3930 #[allow(clippy::enum_variant_names)]
3931 enum GeneratedField {
3932 Type,
3933 DistKeyIndices,
3934 OutputMapping,
3935 }
3936 impl<'de> serde::Deserialize<'de> for GeneratedField {
3937 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3938 where
3939 D: serde::Deserializer<'de>,
3940 {
3941 struct GeneratedVisitor;
3942
3943 impl serde::de::Visitor<'_> for GeneratedVisitor {
3944 type Value = GeneratedField;
3945
3946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3947 write!(formatter, "expected one of: {:?}", &FIELDS)
3948 }
3949
3950 #[allow(unused_variables)]
3951 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3952 where
3953 E: serde::de::Error,
3954 {
3955 match value {
3956 "type" => Ok(GeneratedField::Type),
3957 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3958 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3959 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3960 }
3961 }
3962 }
3963 deserializer.deserialize_identifier(GeneratedVisitor)
3964 }
3965 }
3966 struct GeneratedVisitor;
3967 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3968 type Value = DispatchStrategy;
3969
3970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3971 formatter.write_str("struct stream_plan.DispatchStrategy")
3972 }
3973
3974 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3975 where
3976 V: serde::de::MapAccess<'de>,
3977 {
3978 let mut r#type__ = None;
3979 let mut dist_key_indices__ = None;
3980 let mut output_mapping__ = None;
3981 while let Some(k) = map_.next_key()? {
3982 match k {
3983 GeneratedField::Type => {
3984 if r#type__.is_some() {
3985 return Err(serde::de::Error::duplicate_field("type"));
3986 }
3987 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3988 }
3989 GeneratedField::DistKeyIndices => {
3990 if dist_key_indices__.is_some() {
3991 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3992 }
3993 dist_key_indices__ =
3994 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3995 .into_iter().map(|x| x.0).collect())
3996 ;
3997 }
3998 GeneratedField::OutputMapping => {
3999 if output_mapping__.is_some() {
4000 return Err(serde::de::Error::duplicate_field("outputMapping"));
4001 }
4002 output_mapping__ = map_.next_value()?;
4003 }
4004 }
4005 }
4006 Ok(DispatchStrategy {
4007 r#type: r#type__.unwrap_or_default(),
4008 dist_key_indices: dist_key_indices__.unwrap_or_default(),
4009 output_mapping: output_mapping__,
4010 })
4011 }
4012 }
4013 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
4014 }
4015}
4016impl serde::Serialize for Dispatcher {
4017 #[allow(deprecated)]
4018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4019 where
4020 S: serde::Serializer,
4021 {
4022 use serde::ser::SerializeStruct;
4023 let mut len = 0;
4024 if self.r#type != 0 {
4025 len += 1;
4026 }
4027 if !self.dist_key_indices.is_empty() {
4028 len += 1;
4029 }
4030 if self.output_mapping.is_some() {
4031 len += 1;
4032 }
4033 if self.hash_mapping.is_some() {
4034 len += 1;
4035 }
4036 if self.dispatcher_id != 0 {
4037 len += 1;
4038 }
4039 if !self.downstream_actor_id.is_empty() {
4040 len += 1;
4041 }
4042 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
4043 if self.r#type != 0 {
4044 let v = DispatcherType::try_from(self.r#type)
4045 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
4046 struct_ser.serialize_field("type", &v)?;
4047 }
4048 if !self.dist_key_indices.is_empty() {
4049 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
4050 }
4051 if let Some(v) = self.output_mapping.as_ref() {
4052 struct_ser.serialize_field("outputMapping", v)?;
4053 }
4054 if let Some(v) = self.hash_mapping.as_ref() {
4055 struct_ser.serialize_field("hashMapping", v)?;
4056 }
4057 if self.dispatcher_id != 0 {
4058 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
4059 }
4060 if !self.downstream_actor_id.is_empty() {
4061 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
4062 }
4063 struct_ser.end()
4064 }
4065}
4066impl<'de> serde::Deserialize<'de> for Dispatcher {
4067 #[allow(deprecated)]
4068 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4069 where
4070 D: serde::Deserializer<'de>,
4071 {
4072 const FIELDS: &[&str] = &[
4073 "type",
4074 "dist_key_indices",
4075 "distKeyIndices",
4076 "output_mapping",
4077 "outputMapping",
4078 "hash_mapping",
4079 "hashMapping",
4080 "dispatcher_id",
4081 "dispatcherId",
4082 "downstream_actor_id",
4083 "downstreamActorId",
4084 ];
4085
4086 #[allow(clippy::enum_variant_names)]
4087 enum GeneratedField {
4088 Type,
4089 DistKeyIndices,
4090 OutputMapping,
4091 HashMapping,
4092 DispatcherId,
4093 DownstreamActorId,
4094 }
4095 impl<'de> serde::Deserialize<'de> for GeneratedField {
4096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4097 where
4098 D: serde::Deserializer<'de>,
4099 {
4100 struct GeneratedVisitor;
4101
4102 impl serde::de::Visitor<'_> for GeneratedVisitor {
4103 type Value = GeneratedField;
4104
4105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4106 write!(formatter, "expected one of: {:?}", &FIELDS)
4107 }
4108
4109 #[allow(unused_variables)]
4110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4111 where
4112 E: serde::de::Error,
4113 {
4114 match value {
4115 "type" => Ok(GeneratedField::Type),
4116 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
4117 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
4118 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
4119 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
4120 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
4121 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4122 }
4123 }
4124 }
4125 deserializer.deserialize_identifier(GeneratedVisitor)
4126 }
4127 }
4128 struct GeneratedVisitor;
4129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4130 type Value = Dispatcher;
4131
4132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4133 formatter.write_str("struct stream_plan.Dispatcher")
4134 }
4135
4136 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
4137 where
4138 V: serde::de::MapAccess<'de>,
4139 {
4140 let mut r#type__ = None;
4141 let mut dist_key_indices__ = None;
4142 let mut output_mapping__ = None;
4143 let mut hash_mapping__ = None;
4144 let mut dispatcher_id__ = None;
4145 let mut downstream_actor_id__ = None;
4146 while let Some(k) = map_.next_key()? {
4147 match k {
4148 GeneratedField::Type => {
4149 if r#type__.is_some() {
4150 return Err(serde::de::Error::duplicate_field("type"));
4151 }
4152 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
4153 }
4154 GeneratedField::DistKeyIndices => {
4155 if dist_key_indices__.is_some() {
4156 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
4157 }
4158 dist_key_indices__ =
4159 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4160 .into_iter().map(|x| x.0).collect())
4161 ;
4162 }
4163 GeneratedField::OutputMapping => {
4164 if output_mapping__.is_some() {
4165 return Err(serde::de::Error::duplicate_field("outputMapping"));
4166 }
4167 output_mapping__ = map_.next_value()?;
4168 }
4169 GeneratedField::HashMapping => {
4170 if hash_mapping__.is_some() {
4171 return Err(serde::de::Error::duplicate_field("hashMapping"));
4172 }
4173 hash_mapping__ = map_.next_value()?;
4174 }
4175 GeneratedField::DispatcherId => {
4176 if dispatcher_id__.is_some() {
4177 return Err(serde::de::Error::duplicate_field("dispatcherId"));
4178 }
4179 dispatcher_id__ =
4180 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4181 ;
4182 }
4183 GeneratedField::DownstreamActorId => {
4184 if downstream_actor_id__.is_some() {
4185 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
4186 }
4187 downstream_actor_id__ =
4188 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4189 .into_iter().map(|x| x.0).collect())
4190 ;
4191 }
4192 }
4193 }
4194 Ok(Dispatcher {
4195 r#type: r#type__.unwrap_or_default(),
4196 dist_key_indices: dist_key_indices__.unwrap_or_default(),
4197 output_mapping: output_mapping__,
4198 hash_mapping: hash_mapping__,
4199 dispatcher_id: dispatcher_id__.unwrap_or_default(),
4200 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
4201 })
4202 }
4203 }
4204 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
4205 }
4206}
4207impl serde::Serialize for DispatcherType {
4208 #[allow(deprecated)]
4209 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4210 where
4211 S: serde::Serializer,
4212 {
4213 let variant = match self {
4214 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
4215 Self::Hash => "DISPATCHER_TYPE_HASH",
4216 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
4217 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
4218 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
4219 };
4220 serializer.serialize_str(variant)
4221 }
4222}
4223impl<'de> serde::Deserialize<'de> for DispatcherType {
4224 #[allow(deprecated)]
4225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4226 where
4227 D: serde::Deserializer<'de>,
4228 {
4229 const FIELDS: &[&str] = &[
4230 "DISPATCHER_TYPE_UNSPECIFIED",
4231 "DISPATCHER_TYPE_HASH",
4232 "DISPATCHER_TYPE_BROADCAST",
4233 "DISPATCHER_TYPE_SIMPLE",
4234 "DISPATCHER_TYPE_NO_SHUFFLE",
4235 ];
4236
4237 struct GeneratedVisitor;
4238
4239 impl serde::de::Visitor<'_> for GeneratedVisitor {
4240 type Value = DispatcherType;
4241
4242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4243 write!(formatter, "expected one of: {:?}", &FIELDS)
4244 }
4245
4246 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4247 where
4248 E: serde::de::Error,
4249 {
4250 i32::try_from(v)
4251 .ok()
4252 .and_then(|x| x.try_into().ok())
4253 .ok_or_else(|| {
4254 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4255 })
4256 }
4257
4258 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4259 where
4260 E: serde::de::Error,
4261 {
4262 i32::try_from(v)
4263 .ok()
4264 .and_then(|x| x.try_into().ok())
4265 .ok_or_else(|| {
4266 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4267 })
4268 }
4269
4270 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4271 where
4272 E: serde::de::Error,
4273 {
4274 match value {
4275 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
4276 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
4277 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
4278 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
4279 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
4280 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4281 }
4282 }
4283 }
4284 deserializer.deserialize_any(GeneratedVisitor)
4285 }
4286}
4287impl serde::Serialize for Dispatchers {
4288 #[allow(deprecated)]
4289 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4290 where
4291 S: serde::Serializer,
4292 {
4293 use serde::ser::SerializeStruct;
4294 let mut len = 0;
4295 if !self.dispatchers.is_empty() {
4296 len += 1;
4297 }
4298 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
4299 if !self.dispatchers.is_empty() {
4300 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
4301 }
4302 struct_ser.end()
4303 }
4304}
4305impl<'de> serde::Deserialize<'de> for Dispatchers {
4306 #[allow(deprecated)]
4307 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4308 where
4309 D: serde::Deserializer<'de>,
4310 {
4311 const FIELDS: &[&str] = &[
4312 "dispatchers",
4313 ];
4314
4315 #[allow(clippy::enum_variant_names)]
4316 enum GeneratedField {
4317 Dispatchers,
4318 }
4319 impl<'de> serde::Deserialize<'de> for GeneratedField {
4320 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4321 where
4322 D: serde::Deserializer<'de>,
4323 {
4324 struct GeneratedVisitor;
4325
4326 impl serde::de::Visitor<'_> for GeneratedVisitor {
4327 type Value = GeneratedField;
4328
4329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4330 write!(formatter, "expected one of: {:?}", &FIELDS)
4331 }
4332
4333 #[allow(unused_variables)]
4334 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4335 where
4336 E: serde::de::Error,
4337 {
4338 match value {
4339 "dispatchers" => Ok(GeneratedField::Dispatchers),
4340 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4341 }
4342 }
4343 }
4344 deserializer.deserialize_identifier(GeneratedVisitor)
4345 }
4346 }
4347 struct GeneratedVisitor;
4348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4349 type Value = Dispatchers;
4350
4351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4352 formatter.write_str("struct stream_plan.Dispatchers")
4353 }
4354
4355 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
4356 where
4357 V: serde::de::MapAccess<'de>,
4358 {
4359 let mut dispatchers__ = None;
4360 while let Some(k) = map_.next_key()? {
4361 match k {
4362 GeneratedField::Dispatchers => {
4363 if dispatchers__.is_some() {
4364 return Err(serde::de::Error::duplicate_field("dispatchers"));
4365 }
4366 dispatchers__ = Some(map_.next_value()?);
4367 }
4368 }
4369 }
4370 Ok(Dispatchers {
4371 dispatchers: dispatchers__.unwrap_or_default(),
4372 })
4373 }
4374 }
4375 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
4376 }
4377}
4378impl serde::Serialize for DmlNode {
4379 #[allow(deprecated)]
4380 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4381 where
4382 S: serde::Serializer,
4383 {
4384 use serde::ser::SerializeStruct;
4385 let mut len = 0;
4386 if self.table_id != 0 {
4387 len += 1;
4388 }
4389 if self.table_version_id != 0 {
4390 len += 1;
4391 }
4392 if !self.column_descs.is_empty() {
4393 len += 1;
4394 }
4395 if self.rate_limit.is_some() {
4396 len += 1;
4397 }
4398 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
4399 if self.table_id != 0 {
4400 struct_ser.serialize_field("tableId", &self.table_id)?;
4401 }
4402 if self.table_version_id != 0 {
4403 #[allow(clippy::needless_borrow)]
4404 #[allow(clippy::needless_borrows_for_generic_args)]
4405 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
4406 }
4407 if !self.column_descs.is_empty() {
4408 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
4409 }
4410 if let Some(v) = self.rate_limit.as_ref() {
4411 struct_ser.serialize_field("rateLimit", v)?;
4412 }
4413 struct_ser.end()
4414 }
4415}
4416impl<'de> serde::Deserialize<'de> for DmlNode {
4417 #[allow(deprecated)]
4418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4419 where
4420 D: serde::Deserializer<'de>,
4421 {
4422 const FIELDS: &[&str] = &[
4423 "table_id",
4424 "tableId",
4425 "table_version_id",
4426 "tableVersionId",
4427 "column_descs",
4428 "columnDescs",
4429 "rate_limit",
4430 "rateLimit",
4431 ];
4432
4433 #[allow(clippy::enum_variant_names)]
4434 enum GeneratedField {
4435 TableId,
4436 TableVersionId,
4437 ColumnDescs,
4438 RateLimit,
4439 }
4440 impl<'de> serde::Deserialize<'de> for GeneratedField {
4441 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4442 where
4443 D: serde::Deserializer<'de>,
4444 {
4445 struct GeneratedVisitor;
4446
4447 impl serde::de::Visitor<'_> for GeneratedVisitor {
4448 type Value = GeneratedField;
4449
4450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4451 write!(formatter, "expected one of: {:?}", &FIELDS)
4452 }
4453
4454 #[allow(unused_variables)]
4455 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4456 where
4457 E: serde::de::Error,
4458 {
4459 match value {
4460 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4461 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4462 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4463 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4464 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4465 }
4466 }
4467 }
4468 deserializer.deserialize_identifier(GeneratedVisitor)
4469 }
4470 }
4471 struct GeneratedVisitor;
4472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4473 type Value = DmlNode;
4474
4475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4476 formatter.write_str("struct stream_plan.DmlNode")
4477 }
4478
4479 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4480 where
4481 V: serde::de::MapAccess<'de>,
4482 {
4483 let mut table_id__ = None;
4484 let mut table_version_id__ = None;
4485 let mut column_descs__ = None;
4486 let mut rate_limit__ = None;
4487 while let Some(k) = map_.next_key()? {
4488 match k {
4489 GeneratedField::TableId => {
4490 if table_id__.is_some() {
4491 return Err(serde::de::Error::duplicate_field("tableId"));
4492 }
4493 table_id__ =
4494 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4495 ;
4496 }
4497 GeneratedField::TableVersionId => {
4498 if table_version_id__.is_some() {
4499 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4500 }
4501 table_version_id__ =
4502 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4503 ;
4504 }
4505 GeneratedField::ColumnDescs => {
4506 if column_descs__.is_some() {
4507 return Err(serde::de::Error::duplicate_field("columnDescs"));
4508 }
4509 column_descs__ = Some(map_.next_value()?);
4510 }
4511 GeneratedField::RateLimit => {
4512 if rate_limit__.is_some() {
4513 return Err(serde::de::Error::duplicate_field("rateLimit"));
4514 }
4515 rate_limit__ =
4516 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4517 ;
4518 }
4519 }
4520 }
4521 Ok(DmlNode {
4522 table_id: table_id__.unwrap_or_default(),
4523 table_version_id: table_version_id__.unwrap_or_default(),
4524 column_descs: column_descs__.unwrap_or_default(),
4525 rate_limit: rate_limit__,
4526 })
4527 }
4528 }
4529 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4530 }
4531}
4532impl serde::Serialize for DropSubscriptionsMutation {
4533 #[allow(deprecated)]
4534 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4535 where
4536 S: serde::Serializer,
4537 {
4538 use serde::ser::SerializeStruct;
4539 let mut len = 0;
4540 if !self.info.is_empty() {
4541 len += 1;
4542 }
4543 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4544 if !self.info.is_empty() {
4545 struct_ser.serialize_field("info", &self.info)?;
4546 }
4547 struct_ser.end()
4548 }
4549}
4550impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4551 #[allow(deprecated)]
4552 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4553 where
4554 D: serde::Deserializer<'de>,
4555 {
4556 const FIELDS: &[&str] = &[
4557 "info",
4558 ];
4559
4560 #[allow(clippy::enum_variant_names)]
4561 enum GeneratedField {
4562 Info,
4563 }
4564 impl<'de> serde::Deserialize<'de> for GeneratedField {
4565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4566 where
4567 D: serde::Deserializer<'de>,
4568 {
4569 struct GeneratedVisitor;
4570
4571 impl serde::de::Visitor<'_> for GeneratedVisitor {
4572 type Value = GeneratedField;
4573
4574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4575 write!(formatter, "expected one of: {:?}", &FIELDS)
4576 }
4577
4578 #[allow(unused_variables)]
4579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4580 where
4581 E: serde::de::Error,
4582 {
4583 match value {
4584 "info" => Ok(GeneratedField::Info),
4585 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4586 }
4587 }
4588 }
4589 deserializer.deserialize_identifier(GeneratedVisitor)
4590 }
4591 }
4592 struct GeneratedVisitor;
4593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4594 type Value = DropSubscriptionsMutation;
4595
4596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4597 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4598 }
4599
4600 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4601 where
4602 V: serde::de::MapAccess<'de>,
4603 {
4604 let mut info__ = None;
4605 while let Some(k) = map_.next_key()? {
4606 match k {
4607 GeneratedField::Info => {
4608 if info__.is_some() {
4609 return Err(serde::de::Error::duplicate_field("info"));
4610 }
4611 info__ = Some(map_.next_value()?);
4612 }
4613 }
4614 }
4615 Ok(DropSubscriptionsMutation {
4616 info: info__.unwrap_or_default(),
4617 })
4618 }
4619 }
4620 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4621 }
4622}
4623impl serde::Serialize for DynamicFilterNode {
4624 #[allow(deprecated)]
4625 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4626 where
4627 S: serde::Serializer,
4628 {
4629 use serde::ser::SerializeStruct;
4630 let mut len = 0;
4631 if self.left_key != 0 {
4632 len += 1;
4633 }
4634 if self.condition.is_some() {
4635 len += 1;
4636 }
4637 if self.left_table.is_some() {
4638 len += 1;
4639 }
4640 if self.right_table.is_some() {
4641 len += 1;
4642 }
4643 if self.condition_always_relax {
4644 len += 1;
4645 }
4646 if self.cleaned_by_watermark {
4647 len += 1;
4648 }
4649 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4650 if self.left_key != 0 {
4651 struct_ser.serialize_field("leftKey", &self.left_key)?;
4652 }
4653 if let Some(v) = self.condition.as_ref() {
4654 struct_ser.serialize_field("condition", v)?;
4655 }
4656 if let Some(v) = self.left_table.as_ref() {
4657 struct_ser.serialize_field("leftTable", v)?;
4658 }
4659 if let Some(v) = self.right_table.as_ref() {
4660 struct_ser.serialize_field("rightTable", v)?;
4661 }
4662 if self.condition_always_relax {
4663 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4664 }
4665 if self.cleaned_by_watermark {
4666 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4667 }
4668 struct_ser.end()
4669 }
4670}
4671impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4672 #[allow(deprecated)]
4673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4674 where
4675 D: serde::Deserializer<'de>,
4676 {
4677 const FIELDS: &[&str] = &[
4678 "left_key",
4679 "leftKey",
4680 "condition",
4681 "left_table",
4682 "leftTable",
4683 "right_table",
4684 "rightTable",
4685 "condition_always_relax",
4686 "conditionAlwaysRelax",
4687 "cleaned_by_watermark",
4688 "cleanedByWatermark",
4689 ];
4690
4691 #[allow(clippy::enum_variant_names)]
4692 enum GeneratedField {
4693 LeftKey,
4694 Condition,
4695 LeftTable,
4696 RightTable,
4697 ConditionAlwaysRelax,
4698 CleanedByWatermark,
4699 }
4700 impl<'de> serde::Deserialize<'de> for GeneratedField {
4701 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4702 where
4703 D: serde::Deserializer<'de>,
4704 {
4705 struct GeneratedVisitor;
4706
4707 impl serde::de::Visitor<'_> for GeneratedVisitor {
4708 type Value = GeneratedField;
4709
4710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4711 write!(formatter, "expected one of: {:?}", &FIELDS)
4712 }
4713
4714 #[allow(unused_variables)]
4715 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4716 where
4717 E: serde::de::Error,
4718 {
4719 match value {
4720 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4721 "condition" => Ok(GeneratedField::Condition),
4722 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4723 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4724 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4725 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4726 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4727 }
4728 }
4729 }
4730 deserializer.deserialize_identifier(GeneratedVisitor)
4731 }
4732 }
4733 struct GeneratedVisitor;
4734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4735 type Value = DynamicFilterNode;
4736
4737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4738 formatter.write_str("struct stream_plan.DynamicFilterNode")
4739 }
4740
4741 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4742 where
4743 V: serde::de::MapAccess<'de>,
4744 {
4745 let mut left_key__ = None;
4746 let mut condition__ = None;
4747 let mut left_table__ = None;
4748 let mut right_table__ = None;
4749 let mut condition_always_relax__ = None;
4750 let mut cleaned_by_watermark__ = None;
4751 while let Some(k) = map_.next_key()? {
4752 match k {
4753 GeneratedField::LeftKey => {
4754 if left_key__.is_some() {
4755 return Err(serde::de::Error::duplicate_field("leftKey"));
4756 }
4757 left_key__ =
4758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4759 ;
4760 }
4761 GeneratedField::Condition => {
4762 if condition__.is_some() {
4763 return Err(serde::de::Error::duplicate_field("condition"));
4764 }
4765 condition__ = map_.next_value()?;
4766 }
4767 GeneratedField::LeftTable => {
4768 if left_table__.is_some() {
4769 return Err(serde::de::Error::duplicate_field("leftTable"));
4770 }
4771 left_table__ = map_.next_value()?;
4772 }
4773 GeneratedField::RightTable => {
4774 if right_table__.is_some() {
4775 return Err(serde::de::Error::duplicate_field("rightTable"));
4776 }
4777 right_table__ = map_.next_value()?;
4778 }
4779 GeneratedField::ConditionAlwaysRelax => {
4780 if condition_always_relax__.is_some() {
4781 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4782 }
4783 condition_always_relax__ = Some(map_.next_value()?);
4784 }
4785 GeneratedField::CleanedByWatermark => {
4786 if cleaned_by_watermark__.is_some() {
4787 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4788 }
4789 cleaned_by_watermark__ = Some(map_.next_value()?);
4790 }
4791 }
4792 }
4793 Ok(DynamicFilterNode {
4794 left_key: left_key__.unwrap_or_default(),
4795 condition: condition__,
4796 left_table: left_table__,
4797 right_table: right_table__,
4798 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4799 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4800 })
4801 }
4802 }
4803 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4804 }
4805}
4806impl serde::Serialize for EowcGapFillNode {
4807 #[allow(deprecated)]
4808 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4809 where
4810 S: serde::Serializer,
4811 {
4812 use serde::ser::SerializeStruct;
4813 let mut len = 0;
4814 if self.time_column_index != 0 {
4815 len += 1;
4816 }
4817 if self.interval.is_some() {
4818 len += 1;
4819 }
4820 if !self.fill_columns.is_empty() {
4821 len += 1;
4822 }
4823 if !self.fill_strategies.is_empty() {
4824 len += 1;
4825 }
4826 if self.prev_row_table.is_some() {
4827 len += 1;
4828 }
4829 if !self.partition_by_indices.is_empty() {
4830 len += 1;
4831 }
4832 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4833 if self.time_column_index != 0 {
4834 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4835 }
4836 if let Some(v) = self.interval.as_ref() {
4837 struct_ser.serialize_field("interval", v)?;
4838 }
4839 if !self.fill_columns.is_empty() {
4840 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4841 }
4842 if !self.fill_strategies.is_empty() {
4843 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4844 }
4845 if let Some(v) = self.prev_row_table.as_ref() {
4846 struct_ser.serialize_field("prevRowTable", v)?;
4847 }
4848 if !self.partition_by_indices.is_empty() {
4849 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
4850 }
4851 struct_ser.end()
4852 }
4853}
4854impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4855 #[allow(deprecated)]
4856 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4857 where
4858 D: serde::Deserializer<'de>,
4859 {
4860 const FIELDS: &[&str] = &[
4861 "time_column_index",
4862 "timeColumnIndex",
4863 "interval",
4864 "fill_columns",
4865 "fillColumns",
4866 "fill_strategies",
4867 "fillStrategies",
4868 "prev_row_table",
4869 "prevRowTable",
4870 "partition_by_indices",
4871 "partitionByIndices",
4872 ];
4873
4874 #[allow(clippy::enum_variant_names)]
4875 enum GeneratedField {
4876 TimeColumnIndex,
4877 Interval,
4878 FillColumns,
4879 FillStrategies,
4880 PrevRowTable,
4881 PartitionByIndices,
4882 }
4883 impl<'de> serde::Deserialize<'de> for GeneratedField {
4884 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4885 where
4886 D: serde::Deserializer<'de>,
4887 {
4888 struct GeneratedVisitor;
4889
4890 impl serde::de::Visitor<'_> for GeneratedVisitor {
4891 type Value = GeneratedField;
4892
4893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4894 write!(formatter, "expected one of: {:?}", &FIELDS)
4895 }
4896
4897 #[allow(unused_variables)]
4898 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4899 where
4900 E: serde::de::Error,
4901 {
4902 match value {
4903 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4904 "interval" => Ok(GeneratedField::Interval),
4905 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4906 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4907 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4908 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
4909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4910 }
4911 }
4912 }
4913 deserializer.deserialize_identifier(GeneratedVisitor)
4914 }
4915 }
4916 struct GeneratedVisitor;
4917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4918 type Value = EowcGapFillNode;
4919
4920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4921 formatter.write_str("struct stream_plan.EowcGapFillNode")
4922 }
4923
4924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4925 where
4926 V: serde::de::MapAccess<'de>,
4927 {
4928 let mut time_column_index__ = None;
4929 let mut interval__ = None;
4930 let mut fill_columns__ = None;
4931 let mut fill_strategies__ = None;
4932 let mut prev_row_table__ = None;
4933 let mut partition_by_indices__ = None;
4934 while let Some(k) = map_.next_key()? {
4935 match k {
4936 GeneratedField::TimeColumnIndex => {
4937 if time_column_index__.is_some() {
4938 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4939 }
4940 time_column_index__ =
4941 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4942 ;
4943 }
4944 GeneratedField::Interval => {
4945 if interval__.is_some() {
4946 return Err(serde::de::Error::duplicate_field("interval"));
4947 }
4948 interval__ = map_.next_value()?;
4949 }
4950 GeneratedField::FillColumns => {
4951 if fill_columns__.is_some() {
4952 return Err(serde::de::Error::duplicate_field("fillColumns"));
4953 }
4954 fill_columns__ =
4955 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4956 .into_iter().map(|x| x.0).collect())
4957 ;
4958 }
4959 GeneratedField::FillStrategies => {
4960 if fill_strategies__.is_some() {
4961 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4962 }
4963 fill_strategies__ = Some(map_.next_value()?);
4964 }
4965 GeneratedField::PrevRowTable => {
4966 if prev_row_table__.is_some() {
4967 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4968 }
4969 prev_row_table__ = map_.next_value()?;
4970 }
4971 GeneratedField::PartitionByIndices => {
4972 if partition_by_indices__.is_some() {
4973 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
4974 }
4975 partition_by_indices__ =
4976 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4977 .into_iter().map(|x| x.0).collect())
4978 ;
4979 }
4980 }
4981 }
4982 Ok(EowcGapFillNode {
4983 time_column_index: time_column_index__.unwrap_or_default(),
4984 interval: interval__,
4985 fill_columns: fill_columns__.unwrap_or_default(),
4986 fill_strategies: fill_strategies__.unwrap_or_default(),
4987 prev_row_table: prev_row_table__,
4988 partition_by_indices: partition_by_indices__.unwrap_or_default(),
4989 })
4990 }
4991 }
4992 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4993 }
4994}
4995impl serde::Serialize for EowcOverWindowNode {
4996 #[allow(deprecated)]
4997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4998 where
4999 S: serde::Serializer,
5000 {
5001 use serde::ser::SerializeStruct;
5002 let mut len = 0;
5003 if !self.calls.is_empty() {
5004 len += 1;
5005 }
5006 if !self.partition_by.is_empty() {
5007 len += 1;
5008 }
5009 if !self.order_by.is_empty() {
5010 len += 1;
5011 }
5012 if self.state_table.is_some() {
5013 len += 1;
5014 }
5015 if self.intermediate_state_table.is_some() {
5016 len += 1;
5017 }
5018 if self.watermark_trigger_table.is_some() {
5019 len += 1;
5020 }
5021 if self.version != 0 {
5022 len += 1;
5023 }
5024 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
5025 if !self.calls.is_empty() {
5026 struct_ser.serialize_field("calls", &self.calls)?;
5027 }
5028 if !self.partition_by.is_empty() {
5029 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
5030 }
5031 if !self.order_by.is_empty() {
5032 struct_ser.serialize_field("orderBy", &self.order_by)?;
5033 }
5034 if let Some(v) = self.state_table.as_ref() {
5035 struct_ser.serialize_field("stateTable", v)?;
5036 }
5037 if let Some(v) = self.intermediate_state_table.as_ref() {
5038 struct_ser.serialize_field("intermediateStateTable", v)?;
5039 }
5040 if let Some(v) = self.watermark_trigger_table.as_ref() {
5041 struct_ser.serialize_field("watermarkTriggerTable", v)?;
5042 }
5043 if self.version != 0 {
5044 let v = EowcOverWindowNodeVersion::try_from(self.version)
5045 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5046 struct_ser.serialize_field("version", &v)?;
5047 }
5048 struct_ser.end()
5049 }
5050}
5051impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
5052 #[allow(deprecated)]
5053 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5054 where
5055 D: serde::Deserializer<'de>,
5056 {
5057 const FIELDS: &[&str] = &[
5058 "calls",
5059 "partition_by",
5060 "partitionBy",
5061 "order_by",
5062 "orderBy",
5063 "state_table",
5064 "stateTable",
5065 "intermediate_state_table",
5066 "intermediateStateTable",
5067 "watermark_trigger_table",
5068 "watermarkTriggerTable",
5069 "version",
5070 ];
5071
5072 #[allow(clippy::enum_variant_names)]
5073 enum GeneratedField {
5074 Calls,
5075 PartitionBy,
5076 OrderBy,
5077 StateTable,
5078 IntermediateStateTable,
5079 WatermarkTriggerTable,
5080 Version,
5081 }
5082 impl<'de> serde::Deserialize<'de> for GeneratedField {
5083 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5084 where
5085 D: serde::Deserializer<'de>,
5086 {
5087 struct GeneratedVisitor;
5088
5089 impl serde::de::Visitor<'_> for GeneratedVisitor {
5090 type Value = GeneratedField;
5091
5092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5093 write!(formatter, "expected one of: {:?}", &FIELDS)
5094 }
5095
5096 #[allow(unused_variables)]
5097 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5098 where
5099 E: serde::de::Error,
5100 {
5101 match value {
5102 "calls" => Ok(GeneratedField::Calls),
5103 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
5104 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5105 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5106 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5107 "watermarkTriggerTable" | "watermark_trigger_table" => Ok(GeneratedField::WatermarkTriggerTable),
5108 "version" => Ok(GeneratedField::Version),
5109 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5110 }
5111 }
5112 }
5113 deserializer.deserialize_identifier(GeneratedVisitor)
5114 }
5115 }
5116 struct GeneratedVisitor;
5117 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5118 type Value = EowcOverWindowNode;
5119
5120 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5121 formatter.write_str("struct stream_plan.EowcOverWindowNode")
5122 }
5123
5124 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
5125 where
5126 V: serde::de::MapAccess<'de>,
5127 {
5128 let mut calls__ = None;
5129 let mut partition_by__ = None;
5130 let mut order_by__ = None;
5131 let mut state_table__ = None;
5132 let mut intermediate_state_table__ = None;
5133 let mut watermark_trigger_table__ = None;
5134 let mut version__ = None;
5135 while let Some(k) = map_.next_key()? {
5136 match k {
5137 GeneratedField::Calls => {
5138 if calls__.is_some() {
5139 return Err(serde::de::Error::duplicate_field("calls"));
5140 }
5141 calls__ = Some(map_.next_value()?);
5142 }
5143 GeneratedField::PartitionBy => {
5144 if partition_by__.is_some() {
5145 return Err(serde::de::Error::duplicate_field("partitionBy"));
5146 }
5147 partition_by__ =
5148 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5149 .into_iter().map(|x| x.0).collect())
5150 ;
5151 }
5152 GeneratedField::OrderBy => {
5153 if order_by__.is_some() {
5154 return Err(serde::de::Error::duplicate_field("orderBy"));
5155 }
5156 order_by__ = Some(map_.next_value()?);
5157 }
5158 GeneratedField::StateTable => {
5159 if state_table__.is_some() {
5160 return Err(serde::de::Error::duplicate_field("stateTable"));
5161 }
5162 state_table__ = map_.next_value()?;
5163 }
5164 GeneratedField::IntermediateStateTable => {
5165 if intermediate_state_table__.is_some() {
5166 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5167 }
5168 intermediate_state_table__ = map_.next_value()?;
5169 }
5170 GeneratedField::WatermarkTriggerTable => {
5171 if watermark_trigger_table__.is_some() {
5172 return Err(serde::de::Error::duplicate_field("watermarkTriggerTable"));
5173 }
5174 watermark_trigger_table__ = map_.next_value()?;
5175 }
5176 GeneratedField::Version => {
5177 if version__.is_some() {
5178 return Err(serde::de::Error::duplicate_field("version"));
5179 }
5180 version__ = Some(map_.next_value::<EowcOverWindowNodeVersion>()? as i32);
5181 }
5182 }
5183 }
5184 Ok(EowcOverWindowNode {
5185 calls: calls__.unwrap_or_default(),
5186 partition_by: partition_by__.unwrap_or_default(),
5187 order_by: order_by__.unwrap_or_default(),
5188 state_table: state_table__,
5189 intermediate_state_table: intermediate_state_table__,
5190 watermark_trigger_table: watermark_trigger_table__,
5191 version: version__.unwrap_or_default(),
5192 })
5193 }
5194 }
5195 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
5196 }
5197}
5198impl serde::Serialize for EowcOverWindowNodeVersion {
5199 #[allow(deprecated)]
5200 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5201 where
5202 S: serde::Serializer,
5203 {
5204 let variant = match self {
5205 Self::Unspecified => "EOWC_OVER_WINDOW_NODE_VERSION_UNSPECIFIED",
5206 Self::Issue17119 => "EOWC_OVER_WINDOW_NODE_VERSION_ISSUE_17119",
5207 };
5208 serializer.serialize_str(variant)
5209 }
5210}
5211impl<'de> serde::Deserialize<'de> for EowcOverWindowNodeVersion {
5212 #[allow(deprecated)]
5213 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5214 where
5215 D: serde::Deserializer<'de>,
5216 {
5217 const FIELDS: &[&str] = &[
5218 "EOWC_OVER_WINDOW_NODE_VERSION_UNSPECIFIED",
5219 "EOWC_OVER_WINDOW_NODE_VERSION_ISSUE_17119",
5220 ];
5221
5222 struct GeneratedVisitor;
5223
5224 impl serde::de::Visitor<'_> for GeneratedVisitor {
5225 type Value = EowcOverWindowNodeVersion;
5226
5227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5228 write!(formatter, "expected one of: {:?}", &FIELDS)
5229 }
5230
5231 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5232 where
5233 E: serde::de::Error,
5234 {
5235 i32::try_from(v)
5236 .ok()
5237 .and_then(|x| x.try_into().ok())
5238 .ok_or_else(|| {
5239 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5240 })
5241 }
5242
5243 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5244 where
5245 E: serde::de::Error,
5246 {
5247 i32::try_from(v)
5248 .ok()
5249 .and_then(|x| x.try_into().ok())
5250 .ok_or_else(|| {
5251 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5252 })
5253 }
5254
5255 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5256 where
5257 E: serde::de::Error,
5258 {
5259 match value {
5260 "EOWC_OVER_WINDOW_NODE_VERSION_UNSPECIFIED" => Ok(EowcOverWindowNodeVersion::Unspecified),
5261 "EOWC_OVER_WINDOW_NODE_VERSION_ISSUE_17119" => Ok(EowcOverWindowNodeVersion::Issue17119),
5262 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5263 }
5264 }
5265 }
5266 deserializer.deserialize_any(GeneratedVisitor)
5267 }
5268}
5269impl serde::Serialize for ExchangeNode {
5270 #[allow(deprecated)]
5271 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5272 where
5273 S: serde::Serializer,
5274 {
5275 use serde::ser::SerializeStruct;
5276 let mut len = 0;
5277 if self.strategy.is_some() {
5278 len += 1;
5279 }
5280 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
5281 if let Some(v) = self.strategy.as_ref() {
5282 struct_ser.serialize_field("strategy", v)?;
5283 }
5284 struct_ser.end()
5285 }
5286}
5287impl<'de> serde::Deserialize<'de> for ExchangeNode {
5288 #[allow(deprecated)]
5289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5290 where
5291 D: serde::Deserializer<'de>,
5292 {
5293 const FIELDS: &[&str] = &[
5294 "strategy",
5295 ];
5296
5297 #[allow(clippy::enum_variant_names)]
5298 enum GeneratedField {
5299 Strategy,
5300 }
5301 impl<'de> serde::Deserialize<'de> for GeneratedField {
5302 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5303 where
5304 D: serde::Deserializer<'de>,
5305 {
5306 struct GeneratedVisitor;
5307
5308 impl serde::de::Visitor<'_> for GeneratedVisitor {
5309 type Value = GeneratedField;
5310
5311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5312 write!(formatter, "expected one of: {:?}", &FIELDS)
5313 }
5314
5315 #[allow(unused_variables)]
5316 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5317 where
5318 E: serde::de::Error,
5319 {
5320 match value {
5321 "strategy" => Ok(GeneratedField::Strategy),
5322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5323 }
5324 }
5325 }
5326 deserializer.deserialize_identifier(GeneratedVisitor)
5327 }
5328 }
5329 struct GeneratedVisitor;
5330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5331 type Value = ExchangeNode;
5332
5333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5334 formatter.write_str("struct stream_plan.ExchangeNode")
5335 }
5336
5337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
5338 where
5339 V: serde::de::MapAccess<'de>,
5340 {
5341 let mut strategy__ = None;
5342 while let Some(k) = map_.next_key()? {
5343 match k {
5344 GeneratedField::Strategy => {
5345 if strategy__.is_some() {
5346 return Err(serde::de::Error::duplicate_field("strategy"));
5347 }
5348 strategy__ = map_.next_value()?;
5349 }
5350 }
5351 }
5352 Ok(ExchangeNode {
5353 strategy: strategy__,
5354 })
5355 }
5356 }
5357 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
5358 }
5359}
5360impl serde::Serialize for ExpandNode {
5361 #[allow(deprecated)]
5362 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5363 where
5364 S: serde::Serializer,
5365 {
5366 use serde::ser::SerializeStruct;
5367 let mut len = 0;
5368 if !self.column_subsets.is_empty() {
5369 len += 1;
5370 }
5371 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
5372 if !self.column_subsets.is_empty() {
5373 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
5374 }
5375 struct_ser.end()
5376 }
5377}
5378impl<'de> serde::Deserialize<'de> for ExpandNode {
5379 #[allow(deprecated)]
5380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5381 where
5382 D: serde::Deserializer<'de>,
5383 {
5384 const FIELDS: &[&str] = &[
5385 "column_subsets",
5386 "columnSubsets",
5387 ];
5388
5389 #[allow(clippy::enum_variant_names)]
5390 enum GeneratedField {
5391 ColumnSubsets,
5392 }
5393 impl<'de> serde::Deserialize<'de> for GeneratedField {
5394 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5395 where
5396 D: serde::Deserializer<'de>,
5397 {
5398 struct GeneratedVisitor;
5399
5400 impl serde::de::Visitor<'_> for GeneratedVisitor {
5401 type Value = GeneratedField;
5402
5403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5404 write!(formatter, "expected one of: {:?}", &FIELDS)
5405 }
5406
5407 #[allow(unused_variables)]
5408 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5409 where
5410 E: serde::de::Error,
5411 {
5412 match value {
5413 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
5414 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5415 }
5416 }
5417 }
5418 deserializer.deserialize_identifier(GeneratedVisitor)
5419 }
5420 }
5421 struct GeneratedVisitor;
5422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5423 type Value = ExpandNode;
5424
5425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5426 formatter.write_str("struct stream_plan.ExpandNode")
5427 }
5428
5429 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
5430 where
5431 V: serde::de::MapAccess<'de>,
5432 {
5433 let mut column_subsets__ = None;
5434 while let Some(k) = map_.next_key()? {
5435 match k {
5436 GeneratedField::ColumnSubsets => {
5437 if column_subsets__.is_some() {
5438 return Err(serde::de::Error::duplicate_field("columnSubsets"));
5439 }
5440 column_subsets__ = Some(map_.next_value()?);
5441 }
5442 }
5443 }
5444 Ok(ExpandNode {
5445 column_subsets: column_subsets__.unwrap_or_default(),
5446 })
5447 }
5448 }
5449 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
5450 }
5451}
5452impl serde::Serialize for expand_node::Subset {
5453 #[allow(deprecated)]
5454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5455 where
5456 S: serde::Serializer,
5457 {
5458 use serde::ser::SerializeStruct;
5459 let mut len = 0;
5460 if !self.column_indices.is_empty() {
5461 len += 1;
5462 }
5463 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
5464 if !self.column_indices.is_empty() {
5465 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
5466 }
5467 struct_ser.end()
5468 }
5469}
5470impl<'de> serde::Deserialize<'de> for expand_node::Subset {
5471 #[allow(deprecated)]
5472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5473 where
5474 D: serde::Deserializer<'de>,
5475 {
5476 const FIELDS: &[&str] = &[
5477 "column_indices",
5478 "columnIndices",
5479 ];
5480
5481 #[allow(clippy::enum_variant_names)]
5482 enum GeneratedField {
5483 ColumnIndices,
5484 }
5485 impl<'de> serde::Deserialize<'de> for GeneratedField {
5486 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5487 where
5488 D: serde::Deserializer<'de>,
5489 {
5490 struct GeneratedVisitor;
5491
5492 impl serde::de::Visitor<'_> for GeneratedVisitor {
5493 type Value = GeneratedField;
5494
5495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5496 write!(formatter, "expected one of: {:?}", &FIELDS)
5497 }
5498
5499 #[allow(unused_variables)]
5500 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5501 where
5502 E: serde::de::Error,
5503 {
5504 match value {
5505 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
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 = expand_node::Subset;
5516
5517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5518 formatter.write_str("struct stream_plan.ExpandNode.Subset")
5519 }
5520
5521 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
5522 where
5523 V: serde::de::MapAccess<'de>,
5524 {
5525 let mut column_indices__ = None;
5526 while let Some(k) = map_.next_key()? {
5527 match k {
5528 GeneratedField::ColumnIndices => {
5529 if column_indices__.is_some() {
5530 return Err(serde::de::Error::duplicate_field("columnIndices"));
5531 }
5532 column_indices__ =
5533 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5534 .into_iter().map(|x| x.0).collect())
5535 ;
5536 }
5537 }
5538 }
5539 Ok(expand_node::Subset {
5540 column_indices: column_indices__.unwrap_or_default(),
5541 })
5542 }
5543 }
5544 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
5545 }
5546}
5547impl serde::Serialize for FilterNode {
5548 #[allow(deprecated)]
5549 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5550 where
5551 S: serde::Serializer,
5552 {
5553 use serde::ser::SerializeStruct;
5554 let mut len = 0;
5555 if self.search_condition.is_some() {
5556 len += 1;
5557 }
5558 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
5559 if let Some(v) = self.search_condition.as_ref() {
5560 struct_ser.serialize_field("searchCondition", v)?;
5561 }
5562 struct_ser.end()
5563 }
5564}
5565impl<'de> serde::Deserialize<'de> for FilterNode {
5566 #[allow(deprecated)]
5567 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5568 where
5569 D: serde::Deserializer<'de>,
5570 {
5571 const FIELDS: &[&str] = &[
5572 "search_condition",
5573 "searchCondition",
5574 ];
5575
5576 #[allow(clippy::enum_variant_names)]
5577 enum GeneratedField {
5578 SearchCondition,
5579 }
5580 impl<'de> serde::Deserialize<'de> for GeneratedField {
5581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5582 where
5583 D: serde::Deserializer<'de>,
5584 {
5585 struct GeneratedVisitor;
5586
5587 impl serde::de::Visitor<'_> for GeneratedVisitor {
5588 type Value = GeneratedField;
5589
5590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5591 write!(formatter, "expected one of: {:?}", &FIELDS)
5592 }
5593
5594 #[allow(unused_variables)]
5595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5596 where
5597 E: serde::de::Error,
5598 {
5599 match value {
5600 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5601 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5602 }
5603 }
5604 }
5605 deserializer.deserialize_identifier(GeneratedVisitor)
5606 }
5607 }
5608 struct GeneratedVisitor;
5609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5610 type Value = FilterNode;
5611
5612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5613 formatter.write_str("struct stream_plan.FilterNode")
5614 }
5615
5616 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5617 where
5618 V: serde::de::MapAccess<'de>,
5619 {
5620 let mut search_condition__ = None;
5621 while let Some(k) = map_.next_key()? {
5622 match k {
5623 GeneratedField::SearchCondition => {
5624 if search_condition__.is_some() {
5625 return Err(serde::de::Error::duplicate_field("searchCondition"));
5626 }
5627 search_condition__ = map_.next_value()?;
5628 }
5629 }
5630 }
5631 Ok(FilterNode {
5632 search_condition: search_condition__,
5633 })
5634 }
5635 }
5636 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5637 }
5638}
5639impl serde::Serialize for GapFillNode {
5640 #[allow(deprecated)]
5641 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5642 where
5643 S: serde::Serializer,
5644 {
5645 use serde::ser::SerializeStruct;
5646 let mut len = 0;
5647 if self.time_column_index != 0 {
5648 len += 1;
5649 }
5650 if self.interval.is_some() {
5651 len += 1;
5652 }
5653 if !self.fill_columns.is_empty() {
5654 len += 1;
5655 }
5656 if !self.fill_strategies.is_empty() {
5657 len += 1;
5658 }
5659 if self.state_table.is_some() {
5660 len += 1;
5661 }
5662 if !self.partition_by_indices.is_empty() {
5663 len += 1;
5664 }
5665 if !self.pointer_key_indices.is_empty() {
5666 len += 1;
5667 }
5668 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5669 if self.time_column_index != 0 {
5670 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5671 }
5672 if let Some(v) = self.interval.as_ref() {
5673 struct_ser.serialize_field("interval", v)?;
5674 }
5675 if !self.fill_columns.is_empty() {
5676 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5677 }
5678 if !self.fill_strategies.is_empty() {
5679 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5680 }
5681 if let Some(v) = self.state_table.as_ref() {
5682 struct_ser.serialize_field("stateTable", v)?;
5683 }
5684 if !self.partition_by_indices.is_empty() {
5685 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
5686 }
5687 if !self.pointer_key_indices.is_empty() {
5688 struct_ser.serialize_field("pointerKeyIndices", &self.pointer_key_indices)?;
5689 }
5690 struct_ser.end()
5691 }
5692}
5693impl<'de> serde::Deserialize<'de> for GapFillNode {
5694 #[allow(deprecated)]
5695 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5696 where
5697 D: serde::Deserializer<'de>,
5698 {
5699 const FIELDS: &[&str] = &[
5700 "time_column_index",
5701 "timeColumnIndex",
5702 "interval",
5703 "fill_columns",
5704 "fillColumns",
5705 "fill_strategies",
5706 "fillStrategies",
5707 "state_table",
5708 "stateTable",
5709 "partition_by_indices",
5710 "partitionByIndices",
5711 "pointer_key_indices",
5712 "pointerKeyIndices",
5713 ];
5714
5715 #[allow(clippy::enum_variant_names)]
5716 enum GeneratedField {
5717 TimeColumnIndex,
5718 Interval,
5719 FillColumns,
5720 FillStrategies,
5721 StateTable,
5722 PartitionByIndices,
5723 PointerKeyIndices,
5724 }
5725 impl<'de> serde::Deserialize<'de> for GeneratedField {
5726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5727 where
5728 D: serde::Deserializer<'de>,
5729 {
5730 struct GeneratedVisitor;
5731
5732 impl serde::de::Visitor<'_> for GeneratedVisitor {
5733 type Value = GeneratedField;
5734
5735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5736 write!(formatter, "expected one of: {:?}", &FIELDS)
5737 }
5738
5739 #[allow(unused_variables)]
5740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5741 where
5742 E: serde::de::Error,
5743 {
5744 match value {
5745 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5746 "interval" => Ok(GeneratedField::Interval),
5747 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5748 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5749 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5750 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
5751 "pointerKeyIndices" | "pointer_key_indices" => Ok(GeneratedField::PointerKeyIndices),
5752 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5753 }
5754 }
5755 }
5756 deserializer.deserialize_identifier(GeneratedVisitor)
5757 }
5758 }
5759 struct GeneratedVisitor;
5760 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5761 type Value = GapFillNode;
5762
5763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5764 formatter.write_str("struct stream_plan.GapFillNode")
5765 }
5766
5767 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5768 where
5769 V: serde::de::MapAccess<'de>,
5770 {
5771 let mut time_column_index__ = None;
5772 let mut interval__ = None;
5773 let mut fill_columns__ = None;
5774 let mut fill_strategies__ = None;
5775 let mut state_table__ = None;
5776 let mut partition_by_indices__ = None;
5777 let mut pointer_key_indices__ = None;
5778 while let Some(k) = map_.next_key()? {
5779 match k {
5780 GeneratedField::TimeColumnIndex => {
5781 if time_column_index__.is_some() {
5782 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5783 }
5784 time_column_index__ =
5785 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5786 ;
5787 }
5788 GeneratedField::Interval => {
5789 if interval__.is_some() {
5790 return Err(serde::de::Error::duplicate_field("interval"));
5791 }
5792 interval__ = map_.next_value()?;
5793 }
5794 GeneratedField::FillColumns => {
5795 if fill_columns__.is_some() {
5796 return Err(serde::de::Error::duplicate_field("fillColumns"));
5797 }
5798 fill_columns__ =
5799 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5800 .into_iter().map(|x| x.0).collect())
5801 ;
5802 }
5803 GeneratedField::FillStrategies => {
5804 if fill_strategies__.is_some() {
5805 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5806 }
5807 fill_strategies__ = Some(map_.next_value()?);
5808 }
5809 GeneratedField::StateTable => {
5810 if state_table__.is_some() {
5811 return Err(serde::de::Error::duplicate_field("stateTable"));
5812 }
5813 state_table__ = map_.next_value()?;
5814 }
5815 GeneratedField::PartitionByIndices => {
5816 if partition_by_indices__.is_some() {
5817 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
5818 }
5819 partition_by_indices__ =
5820 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5821 .into_iter().map(|x| x.0).collect())
5822 ;
5823 }
5824 GeneratedField::PointerKeyIndices => {
5825 if pointer_key_indices__.is_some() {
5826 return Err(serde::de::Error::duplicate_field("pointerKeyIndices"));
5827 }
5828 pointer_key_indices__ =
5829 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5830 .into_iter().map(|x| x.0).collect())
5831 ;
5832 }
5833 }
5834 }
5835 Ok(GapFillNode {
5836 time_column_index: time_column_index__.unwrap_or_default(),
5837 interval: interval__,
5838 fill_columns: fill_columns__.unwrap_or_default(),
5839 fill_strategies: fill_strategies__.unwrap_or_default(),
5840 state_table: state_table__,
5841 partition_by_indices: partition_by_indices__.unwrap_or_default(),
5842 pointer_key_indices: pointer_key_indices__.unwrap_or_default(),
5843 })
5844 }
5845 }
5846 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5847 }
5848}
5849impl serde::Serialize for GlobalApproxPercentileNode {
5850 #[allow(deprecated)]
5851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5852 where
5853 S: serde::Serializer,
5854 {
5855 use serde::ser::SerializeStruct;
5856 let mut len = 0;
5857 if self.base != 0. {
5858 len += 1;
5859 }
5860 if self.quantile != 0. {
5861 len += 1;
5862 }
5863 if self.bucket_state_table.is_some() {
5864 len += 1;
5865 }
5866 if self.count_state_table.is_some() {
5867 len += 1;
5868 }
5869 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5870 if self.base != 0. {
5871 struct_ser.serialize_field("base", &self.base)?;
5872 }
5873 if self.quantile != 0. {
5874 struct_ser.serialize_field("quantile", &self.quantile)?;
5875 }
5876 if let Some(v) = self.bucket_state_table.as_ref() {
5877 struct_ser.serialize_field("bucketStateTable", v)?;
5878 }
5879 if let Some(v) = self.count_state_table.as_ref() {
5880 struct_ser.serialize_field("countStateTable", v)?;
5881 }
5882 struct_ser.end()
5883 }
5884}
5885impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5886 #[allow(deprecated)]
5887 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5888 where
5889 D: serde::Deserializer<'de>,
5890 {
5891 const FIELDS: &[&str] = &[
5892 "base",
5893 "quantile",
5894 "bucket_state_table",
5895 "bucketStateTable",
5896 "count_state_table",
5897 "countStateTable",
5898 ];
5899
5900 #[allow(clippy::enum_variant_names)]
5901 enum GeneratedField {
5902 Base,
5903 Quantile,
5904 BucketStateTable,
5905 CountStateTable,
5906 }
5907 impl<'de> serde::Deserialize<'de> for GeneratedField {
5908 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5909 where
5910 D: serde::Deserializer<'de>,
5911 {
5912 struct GeneratedVisitor;
5913
5914 impl serde::de::Visitor<'_> for GeneratedVisitor {
5915 type Value = GeneratedField;
5916
5917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5918 write!(formatter, "expected one of: {:?}", &FIELDS)
5919 }
5920
5921 #[allow(unused_variables)]
5922 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5923 where
5924 E: serde::de::Error,
5925 {
5926 match value {
5927 "base" => Ok(GeneratedField::Base),
5928 "quantile" => Ok(GeneratedField::Quantile),
5929 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5930 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5932 }
5933 }
5934 }
5935 deserializer.deserialize_identifier(GeneratedVisitor)
5936 }
5937 }
5938 struct GeneratedVisitor;
5939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5940 type Value = GlobalApproxPercentileNode;
5941
5942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5943 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5944 }
5945
5946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5947 where
5948 V: serde::de::MapAccess<'de>,
5949 {
5950 let mut base__ = None;
5951 let mut quantile__ = None;
5952 let mut bucket_state_table__ = None;
5953 let mut count_state_table__ = None;
5954 while let Some(k) = map_.next_key()? {
5955 match k {
5956 GeneratedField::Base => {
5957 if base__.is_some() {
5958 return Err(serde::de::Error::duplicate_field("base"));
5959 }
5960 base__ =
5961 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5962 ;
5963 }
5964 GeneratedField::Quantile => {
5965 if quantile__.is_some() {
5966 return Err(serde::de::Error::duplicate_field("quantile"));
5967 }
5968 quantile__ =
5969 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5970 ;
5971 }
5972 GeneratedField::BucketStateTable => {
5973 if bucket_state_table__.is_some() {
5974 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5975 }
5976 bucket_state_table__ = map_.next_value()?;
5977 }
5978 GeneratedField::CountStateTable => {
5979 if count_state_table__.is_some() {
5980 return Err(serde::de::Error::duplicate_field("countStateTable"));
5981 }
5982 count_state_table__ = map_.next_value()?;
5983 }
5984 }
5985 }
5986 Ok(GlobalApproxPercentileNode {
5987 base: base__.unwrap_or_default(),
5988 quantile: quantile__.unwrap_or_default(),
5989 bucket_state_table: bucket_state_table__,
5990 count_state_table: count_state_table__,
5991 })
5992 }
5993 }
5994 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5995 }
5996}
5997impl serde::Serialize for GroupTopNNode {
5998 #[allow(deprecated)]
5999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6000 where
6001 S: serde::Serializer,
6002 {
6003 use serde::ser::SerializeStruct;
6004 let mut len = 0;
6005 if self.limit != 0 {
6006 len += 1;
6007 }
6008 if self.offset != 0 {
6009 len += 1;
6010 }
6011 if !self.group_key.is_empty() {
6012 len += 1;
6013 }
6014 if self.table.is_some() {
6015 len += 1;
6016 }
6017 if !self.order_by.is_empty() {
6018 len += 1;
6019 }
6020 if self.with_ties {
6021 len += 1;
6022 }
6023 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
6024 if self.limit != 0 {
6025 #[allow(clippy::needless_borrow)]
6026 #[allow(clippy::needless_borrows_for_generic_args)]
6027 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
6028 }
6029 if self.offset != 0 {
6030 #[allow(clippy::needless_borrow)]
6031 #[allow(clippy::needless_borrows_for_generic_args)]
6032 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
6033 }
6034 if !self.group_key.is_empty() {
6035 struct_ser.serialize_field("groupKey", &self.group_key)?;
6036 }
6037 if let Some(v) = self.table.as_ref() {
6038 struct_ser.serialize_field("table", v)?;
6039 }
6040 if !self.order_by.is_empty() {
6041 struct_ser.serialize_field("orderBy", &self.order_by)?;
6042 }
6043 if self.with_ties {
6044 struct_ser.serialize_field("withTies", &self.with_ties)?;
6045 }
6046 struct_ser.end()
6047 }
6048}
6049impl<'de> serde::Deserialize<'de> for GroupTopNNode {
6050 #[allow(deprecated)]
6051 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6052 where
6053 D: serde::Deserializer<'de>,
6054 {
6055 const FIELDS: &[&str] = &[
6056 "limit",
6057 "offset",
6058 "group_key",
6059 "groupKey",
6060 "table",
6061 "order_by",
6062 "orderBy",
6063 "with_ties",
6064 "withTies",
6065 ];
6066
6067 #[allow(clippy::enum_variant_names)]
6068 enum GeneratedField {
6069 Limit,
6070 Offset,
6071 GroupKey,
6072 Table,
6073 OrderBy,
6074 WithTies,
6075 }
6076 impl<'de> serde::Deserialize<'de> for GeneratedField {
6077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6078 where
6079 D: serde::Deserializer<'de>,
6080 {
6081 struct GeneratedVisitor;
6082
6083 impl serde::de::Visitor<'_> for GeneratedVisitor {
6084 type Value = GeneratedField;
6085
6086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6087 write!(formatter, "expected one of: {:?}", &FIELDS)
6088 }
6089
6090 #[allow(unused_variables)]
6091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6092 where
6093 E: serde::de::Error,
6094 {
6095 match value {
6096 "limit" => Ok(GeneratedField::Limit),
6097 "offset" => Ok(GeneratedField::Offset),
6098 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6099 "table" => Ok(GeneratedField::Table),
6100 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
6101 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
6102 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6103 }
6104 }
6105 }
6106 deserializer.deserialize_identifier(GeneratedVisitor)
6107 }
6108 }
6109 struct GeneratedVisitor;
6110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6111 type Value = GroupTopNNode;
6112
6113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6114 formatter.write_str("struct stream_plan.GroupTopNNode")
6115 }
6116
6117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
6118 where
6119 V: serde::de::MapAccess<'de>,
6120 {
6121 let mut limit__ = None;
6122 let mut offset__ = None;
6123 let mut group_key__ = None;
6124 let mut table__ = None;
6125 let mut order_by__ = None;
6126 let mut with_ties__ = None;
6127 while let Some(k) = map_.next_key()? {
6128 match k {
6129 GeneratedField::Limit => {
6130 if limit__.is_some() {
6131 return Err(serde::de::Error::duplicate_field("limit"));
6132 }
6133 limit__ =
6134 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6135 ;
6136 }
6137 GeneratedField::Offset => {
6138 if offset__.is_some() {
6139 return Err(serde::de::Error::duplicate_field("offset"));
6140 }
6141 offset__ =
6142 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6143 ;
6144 }
6145 GeneratedField::GroupKey => {
6146 if group_key__.is_some() {
6147 return Err(serde::de::Error::duplicate_field("groupKey"));
6148 }
6149 group_key__ =
6150 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6151 .into_iter().map(|x| x.0).collect())
6152 ;
6153 }
6154 GeneratedField::Table => {
6155 if table__.is_some() {
6156 return Err(serde::de::Error::duplicate_field("table"));
6157 }
6158 table__ = map_.next_value()?;
6159 }
6160 GeneratedField::OrderBy => {
6161 if order_by__.is_some() {
6162 return Err(serde::de::Error::duplicate_field("orderBy"));
6163 }
6164 order_by__ = Some(map_.next_value()?);
6165 }
6166 GeneratedField::WithTies => {
6167 if with_ties__.is_some() {
6168 return Err(serde::de::Error::duplicate_field("withTies"));
6169 }
6170 with_ties__ = Some(map_.next_value()?);
6171 }
6172 }
6173 }
6174 Ok(GroupTopNNode {
6175 limit: limit__.unwrap_or_default(),
6176 offset: offset__.unwrap_or_default(),
6177 group_key: group_key__.unwrap_or_default(),
6178 table: table__,
6179 order_by: order_by__.unwrap_or_default(),
6180 with_ties: with_ties__.unwrap_or_default(),
6181 })
6182 }
6183 }
6184 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
6185 }
6186}
6187impl serde::Serialize for HashAggNode {
6188 #[allow(deprecated)]
6189 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6190 where
6191 S: serde::Serializer,
6192 {
6193 use serde::ser::SerializeStruct;
6194 let mut len = 0;
6195 if !self.group_key.is_empty() {
6196 len += 1;
6197 }
6198 if !self.agg_calls.is_empty() {
6199 len += 1;
6200 }
6201 if !self.agg_call_states.is_empty() {
6202 len += 1;
6203 }
6204 if self.intermediate_state_table.is_some() {
6205 len += 1;
6206 }
6207 if self.is_append_only {
6208 len += 1;
6209 }
6210 if !self.distinct_dedup_tables.is_empty() {
6211 len += 1;
6212 }
6213 if self.row_count_index != 0 {
6214 len += 1;
6215 }
6216 if self.emit_on_window_close {
6217 len += 1;
6218 }
6219 if self.version != 0 {
6220 len += 1;
6221 }
6222 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
6223 if !self.group_key.is_empty() {
6224 struct_ser.serialize_field("groupKey", &self.group_key)?;
6225 }
6226 if !self.agg_calls.is_empty() {
6227 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6228 }
6229 if !self.agg_call_states.is_empty() {
6230 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
6231 }
6232 if let Some(v) = self.intermediate_state_table.as_ref() {
6233 struct_ser.serialize_field("intermediateStateTable", v)?;
6234 }
6235 if self.is_append_only {
6236 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
6237 }
6238 if !self.distinct_dedup_tables.is_empty() {
6239 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
6240 }
6241 if self.row_count_index != 0 {
6242 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
6243 }
6244 if self.emit_on_window_close {
6245 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
6246 }
6247 if self.version != 0 {
6248 let v = AggNodeVersion::try_from(self.version)
6249 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
6250 struct_ser.serialize_field("version", &v)?;
6251 }
6252 struct_ser.end()
6253 }
6254}
6255impl<'de> serde::Deserialize<'de> for HashAggNode {
6256 #[allow(deprecated)]
6257 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6258 where
6259 D: serde::Deserializer<'de>,
6260 {
6261 const FIELDS: &[&str] = &[
6262 "group_key",
6263 "groupKey",
6264 "agg_calls",
6265 "aggCalls",
6266 "agg_call_states",
6267 "aggCallStates",
6268 "intermediate_state_table",
6269 "intermediateStateTable",
6270 "is_append_only",
6271 "isAppendOnly",
6272 "distinct_dedup_tables",
6273 "distinctDedupTables",
6274 "row_count_index",
6275 "rowCountIndex",
6276 "emit_on_window_close",
6277 "emitOnWindowClose",
6278 "version",
6279 ];
6280
6281 #[allow(clippy::enum_variant_names)]
6282 enum GeneratedField {
6283 GroupKey,
6284 AggCalls,
6285 AggCallStates,
6286 IntermediateStateTable,
6287 IsAppendOnly,
6288 DistinctDedupTables,
6289 RowCountIndex,
6290 EmitOnWindowClose,
6291 Version,
6292 }
6293 impl<'de> serde::Deserialize<'de> for GeneratedField {
6294 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6295 where
6296 D: serde::Deserializer<'de>,
6297 {
6298 struct GeneratedVisitor;
6299
6300 impl serde::de::Visitor<'_> for GeneratedVisitor {
6301 type Value = GeneratedField;
6302
6303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6304 write!(formatter, "expected one of: {:?}", &FIELDS)
6305 }
6306
6307 #[allow(unused_variables)]
6308 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6309 where
6310 E: serde::de::Error,
6311 {
6312 match value {
6313 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6314 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6315 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
6316 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
6317 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6318 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
6319 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
6320 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
6321 "version" => Ok(GeneratedField::Version),
6322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6323 }
6324 }
6325 }
6326 deserializer.deserialize_identifier(GeneratedVisitor)
6327 }
6328 }
6329 struct GeneratedVisitor;
6330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6331 type Value = HashAggNode;
6332
6333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6334 formatter.write_str("struct stream_plan.HashAggNode")
6335 }
6336
6337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
6338 where
6339 V: serde::de::MapAccess<'de>,
6340 {
6341 let mut group_key__ = None;
6342 let mut agg_calls__ = None;
6343 let mut agg_call_states__ = None;
6344 let mut intermediate_state_table__ = None;
6345 let mut is_append_only__ = None;
6346 let mut distinct_dedup_tables__ = None;
6347 let mut row_count_index__ = None;
6348 let mut emit_on_window_close__ = None;
6349 let mut version__ = None;
6350 while let Some(k) = map_.next_key()? {
6351 match k {
6352 GeneratedField::GroupKey => {
6353 if group_key__.is_some() {
6354 return Err(serde::de::Error::duplicate_field("groupKey"));
6355 }
6356 group_key__ =
6357 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6358 .into_iter().map(|x| x.0).collect())
6359 ;
6360 }
6361 GeneratedField::AggCalls => {
6362 if agg_calls__.is_some() {
6363 return Err(serde::de::Error::duplicate_field("aggCalls"));
6364 }
6365 agg_calls__ = Some(map_.next_value()?);
6366 }
6367 GeneratedField::AggCallStates => {
6368 if agg_call_states__.is_some() {
6369 return Err(serde::de::Error::duplicate_field("aggCallStates"));
6370 }
6371 agg_call_states__ = Some(map_.next_value()?);
6372 }
6373 GeneratedField::IntermediateStateTable => {
6374 if intermediate_state_table__.is_some() {
6375 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
6376 }
6377 intermediate_state_table__ = map_.next_value()?;
6378 }
6379 GeneratedField::IsAppendOnly => {
6380 if is_append_only__.is_some() {
6381 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6382 }
6383 is_append_only__ = Some(map_.next_value()?);
6384 }
6385 GeneratedField::DistinctDedupTables => {
6386 if distinct_dedup_tables__.is_some() {
6387 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
6388 }
6389 distinct_dedup_tables__ = Some(
6390 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6391 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6392 );
6393 }
6394 GeneratedField::RowCountIndex => {
6395 if row_count_index__.is_some() {
6396 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
6397 }
6398 row_count_index__ =
6399 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6400 ;
6401 }
6402 GeneratedField::EmitOnWindowClose => {
6403 if emit_on_window_close__.is_some() {
6404 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
6405 }
6406 emit_on_window_close__ = Some(map_.next_value()?);
6407 }
6408 GeneratedField::Version => {
6409 if version__.is_some() {
6410 return Err(serde::de::Error::duplicate_field("version"));
6411 }
6412 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
6413 }
6414 }
6415 }
6416 Ok(HashAggNode {
6417 group_key: group_key__.unwrap_or_default(),
6418 agg_calls: agg_calls__.unwrap_or_default(),
6419 agg_call_states: agg_call_states__.unwrap_or_default(),
6420 intermediate_state_table: intermediate_state_table__,
6421 is_append_only: is_append_only__.unwrap_or_default(),
6422 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
6423 row_count_index: row_count_index__.unwrap_or_default(),
6424 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
6425 version: version__.unwrap_or_default(),
6426 })
6427 }
6428 }
6429 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
6430 }
6431}
6432impl serde::Serialize for HashJoinNode {
6433 #[allow(deprecated)]
6434 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6435 where
6436 S: serde::Serializer,
6437 {
6438 use serde::ser::SerializeStruct;
6439 let mut len = 0;
6440 if self.join_type != 0 {
6441 len += 1;
6442 }
6443 if !self.left_key.is_empty() {
6444 len += 1;
6445 }
6446 if !self.right_key.is_empty() {
6447 len += 1;
6448 }
6449 if self.condition.is_some() {
6450 len += 1;
6451 }
6452 if self.left_table.is_some() {
6453 len += 1;
6454 }
6455 if self.right_table.is_some() {
6456 len += 1;
6457 }
6458 if self.left_degree_table.is_some() {
6459 len += 1;
6460 }
6461 if self.right_degree_table.is_some() {
6462 len += 1;
6463 }
6464 if !self.output_indices.is_empty() {
6465 len += 1;
6466 }
6467 if !self.left_deduped_input_pk_indices.is_empty() {
6468 len += 1;
6469 }
6470 if !self.right_deduped_input_pk_indices.is_empty() {
6471 len += 1;
6472 }
6473 if !self.null_safe.is_empty() {
6474 len += 1;
6475 }
6476 if self.is_append_only {
6477 len += 1;
6478 }
6479 if self.join_encoding_type != 0 {
6480 len += 1;
6481 }
6482 if self.watermark_handle_desc.is_some() {
6483 len += 1;
6484 }
6485 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
6486 if self.join_type != 0 {
6487 let v = super::plan_common::JoinType::try_from(self.join_type)
6488 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6489 struct_ser.serialize_field("joinType", &v)?;
6490 }
6491 if !self.left_key.is_empty() {
6492 struct_ser.serialize_field("leftKey", &self.left_key)?;
6493 }
6494 if !self.right_key.is_empty() {
6495 struct_ser.serialize_field("rightKey", &self.right_key)?;
6496 }
6497 if let Some(v) = self.condition.as_ref() {
6498 struct_ser.serialize_field("condition", v)?;
6499 }
6500 if let Some(v) = self.left_table.as_ref() {
6501 struct_ser.serialize_field("leftTable", v)?;
6502 }
6503 if let Some(v) = self.right_table.as_ref() {
6504 struct_ser.serialize_field("rightTable", v)?;
6505 }
6506 if let Some(v) = self.left_degree_table.as_ref() {
6507 struct_ser.serialize_field("leftDegreeTable", v)?;
6508 }
6509 if let Some(v) = self.right_degree_table.as_ref() {
6510 struct_ser.serialize_field("rightDegreeTable", v)?;
6511 }
6512 if !self.output_indices.is_empty() {
6513 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6514 }
6515 if !self.left_deduped_input_pk_indices.is_empty() {
6516 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
6517 }
6518 if !self.right_deduped_input_pk_indices.is_empty() {
6519 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
6520 }
6521 if !self.null_safe.is_empty() {
6522 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
6523 }
6524 if self.is_append_only {
6525 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
6526 }
6527 if self.join_encoding_type != 0 {
6528 let v = JoinEncodingType::try_from(self.join_encoding_type)
6529 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
6530 struct_ser.serialize_field("joinEncodingType", &v)?;
6531 }
6532 if let Some(v) = self.watermark_handle_desc.as_ref() {
6533 struct_ser.serialize_field("watermarkHandleDesc", v)?;
6534 }
6535 struct_ser.end()
6536 }
6537}
6538impl<'de> serde::Deserialize<'de> for HashJoinNode {
6539 #[allow(deprecated)]
6540 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6541 where
6542 D: serde::Deserializer<'de>,
6543 {
6544 const FIELDS: &[&str] = &[
6545 "join_type",
6546 "joinType",
6547 "left_key",
6548 "leftKey",
6549 "right_key",
6550 "rightKey",
6551 "condition",
6552 "left_table",
6553 "leftTable",
6554 "right_table",
6555 "rightTable",
6556 "left_degree_table",
6557 "leftDegreeTable",
6558 "right_degree_table",
6559 "rightDegreeTable",
6560 "output_indices",
6561 "outputIndices",
6562 "left_deduped_input_pk_indices",
6563 "leftDedupedInputPkIndices",
6564 "right_deduped_input_pk_indices",
6565 "rightDedupedInputPkIndices",
6566 "null_safe",
6567 "nullSafe",
6568 "is_append_only",
6569 "isAppendOnly",
6570 "join_encoding_type",
6571 "joinEncodingType",
6572 "watermark_handle_desc",
6573 "watermarkHandleDesc",
6574 ];
6575
6576 #[allow(clippy::enum_variant_names)]
6577 enum GeneratedField {
6578 JoinType,
6579 LeftKey,
6580 RightKey,
6581 Condition,
6582 LeftTable,
6583 RightTable,
6584 LeftDegreeTable,
6585 RightDegreeTable,
6586 OutputIndices,
6587 LeftDedupedInputPkIndices,
6588 RightDedupedInputPkIndices,
6589 NullSafe,
6590 IsAppendOnly,
6591 JoinEncodingType,
6592 WatermarkHandleDesc,
6593 }
6594 impl<'de> serde::Deserialize<'de> for GeneratedField {
6595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6596 where
6597 D: serde::Deserializer<'de>,
6598 {
6599 struct GeneratedVisitor;
6600
6601 impl serde::de::Visitor<'_> for GeneratedVisitor {
6602 type Value = GeneratedField;
6603
6604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6605 write!(formatter, "expected one of: {:?}", &FIELDS)
6606 }
6607
6608 #[allow(unused_variables)]
6609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6610 where
6611 E: serde::de::Error,
6612 {
6613 match value {
6614 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6615 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6616 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6617 "condition" => Ok(GeneratedField::Condition),
6618 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
6619 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
6620 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
6621 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
6622 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6623 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
6624 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
6625 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
6626 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6627 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
6628 "watermarkHandleDesc" | "watermark_handle_desc" => Ok(GeneratedField::WatermarkHandleDesc),
6629 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6630 }
6631 }
6632 }
6633 deserializer.deserialize_identifier(GeneratedVisitor)
6634 }
6635 }
6636 struct GeneratedVisitor;
6637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6638 type Value = HashJoinNode;
6639
6640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6641 formatter.write_str("struct stream_plan.HashJoinNode")
6642 }
6643
6644 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6645 where
6646 V: serde::de::MapAccess<'de>,
6647 {
6648 let mut join_type__ = None;
6649 let mut left_key__ = None;
6650 let mut right_key__ = None;
6651 let mut condition__ = None;
6652 let mut left_table__ = None;
6653 let mut right_table__ = None;
6654 let mut left_degree_table__ = None;
6655 let mut right_degree_table__ = None;
6656 let mut output_indices__ = None;
6657 let mut left_deduped_input_pk_indices__ = None;
6658 let mut right_deduped_input_pk_indices__ = None;
6659 let mut null_safe__ = None;
6660 let mut is_append_only__ = None;
6661 let mut join_encoding_type__ = None;
6662 let mut watermark_handle_desc__ = None;
6663 while let Some(k) = map_.next_key()? {
6664 match k {
6665 GeneratedField::JoinType => {
6666 if join_type__.is_some() {
6667 return Err(serde::de::Error::duplicate_field("joinType"));
6668 }
6669 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6670 }
6671 GeneratedField::LeftKey => {
6672 if left_key__.is_some() {
6673 return Err(serde::de::Error::duplicate_field("leftKey"));
6674 }
6675 left_key__ =
6676 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6677 .into_iter().map(|x| x.0).collect())
6678 ;
6679 }
6680 GeneratedField::RightKey => {
6681 if right_key__.is_some() {
6682 return Err(serde::de::Error::duplicate_field("rightKey"));
6683 }
6684 right_key__ =
6685 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6686 .into_iter().map(|x| x.0).collect())
6687 ;
6688 }
6689 GeneratedField::Condition => {
6690 if condition__.is_some() {
6691 return Err(serde::de::Error::duplicate_field("condition"));
6692 }
6693 condition__ = map_.next_value()?;
6694 }
6695 GeneratedField::LeftTable => {
6696 if left_table__.is_some() {
6697 return Err(serde::de::Error::duplicate_field("leftTable"));
6698 }
6699 left_table__ = map_.next_value()?;
6700 }
6701 GeneratedField::RightTable => {
6702 if right_table__.is_some() {
6703 return Err(serde::de::Error::duplicate_field("rightTable"));
6704 }
6705 right_table__ = map_.next_value()?;
6706 }
6707 GeneratedField::LeftDegreeTable => {
6708 if left_degree_table__.is_some() {
6709 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6710 }
6711 left_degree_table__ = map_.next_value()?;
6712 }
6713 GeneratedField::RightDegreeTable => {
6714 if right_degree_table__.is_some() {
6715 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6716 }
6717 right_degree_table__ = map_.next_value()?;
6718 }
6719 GeneratedField::OutputIndices => {
6720 if output_indices__.is_some() {
6721 return Err(serde::de::Error::duplicate_field("outputIndices"));
6722 }
6723 output_indices__ =
6724 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6725 .into_iter().map(|x| x.0).collect())
6726 ;
6727 }
6728 GeneratedField::LeftDedupedInputPkIndices => {
6729 if left_deduped_input_pk_indices__.is_some() {
6730 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6731 }
6732 left_deduped_input_pk_indices__ =
6733 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6734 .into_iter().map(|x| x.0).collect())
6735 ;
6736 }
6737 GeneratedField::RightDedupedInputPkIndices => {
6738 if right_deduped_input_pk_indices__.is_some() {
6739 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6740 }
6741 right_deduped_input_pk_indices__ =
6742 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6743 .into_iter().map(|x| x.0).collect())
6744 ;
6745 }
6746 GeneratedField::NullSafe => {
6747 if null_safe__.is_some() {
6748 return Err(serde::de::Error::duplicate_field("nullSafe"));
6749 }
6750 null_safe__ = Some(map_.next_value()?);
6751 }
6752 GeneratedField::IsAppendOnly => {
6753 if is_append_only__.is_some() {
6754 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6755 }
6756 is_append_only__ = Some(map_.next_value()?);
6757 }
6758 GeneratedField::JoinEncodingType => {
6759 if join_encoding_type__.is_some() {
6760 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6761 }
6762 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6763 }
6764 GeneratedField::WatermarkHandleDesc => {
6765 if watermark_handle_desc__.is_some() {
6766 return Err(serde::de::Error::duplicate_field("watermarkHandleDesc"));
6767 }
6768 watermark_handle_desc__ = map_.next_value()?;
6769 }
6770 }
6771 }
6772 Ok(HashJoinNode {
6773 join_type: join_type__.unwrap_or_default(),
6774 left_key: left_key__.unwrap_or_default(),
6775 right_key: right_key__.unwrap_or_default(),
6776 condition: condition__,
6777 left_table: left_table__,
6778 right_table: right_table__,
6779 left_degree_table: left_degree_table__,
6780 right_degree_table: right_degree_table__,
6781 output_indices: output_indices__.unwrap_or_default(),
6782 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6783 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6784 null_safe: null_safe__.unwrap_or_default(),
6785 is_append_only: is_append_only__.unwrap_or_default(),
6786 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6787 watermark_handle_desc: watermark_handle_desc__,
6788 })
6789 }
6790 }
6791 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6792 }
6793}
6794impl serde::Serialize for HashJoinWatermarkHandleDesc {
6795 #[allow(deprecated)]
6796 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6797 where
6798 S: serde::Serializer,
6799 {
6800 use serde::ser::SerializeStruct;
6801 let mut len = 0;
6802 if !self.watermark_indices_in_jk.is_empty() {
6803 len += 1;
6804 }
6805 if !self.inequality_pairs.is_empty() {
6806 len += 1;
6807 }
6808 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinWatermarkHandleDesc", len)?;
6809 if !self.watermark_indices_in_jk.is_empty() {
6810 struct_ser.serialize_field("watermarkIndicesInJk", &self.watermark_indices_in_jk)?;
6811 }
6812 if !self.inequality_pairs.is_empty() {
6813 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
6814 }
6815 struct_ser.end()
6816 }
6817}
6818impl<'de> serde::Deserialize<'de> for HashJoinWatermarkHandleDesc {
6819 #[allow(deprecated)]
6820 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6821 where
6822 D: serde::Deserializer<'de>,
6823 {
6824 const FIELDS: &[&str] = &[
6825 "watermark_indices_in_jk",
6826 "watermarkIndicesInJk",
6827 "inequality_pairs",
6828 "inequalityPairs",
6829 ];
6830
6831 #[allow(clippy::enum_variant_names)]
6832 enum GeneratedField {
6833 WatermarkIndicesInJk,
6834 InequalityPairs,
6835 }
6836 impl<'de> serde::Deserialize<'de> for GeneratedField {
6837 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6838 where
6839 D: serde::Deserializer<'de>,
6840 {
6841 struct GeneratedVisitor;
6842
6843 impl serde::de::Visitor<'_> for GeneratedVisitor {
6844 type Value = GeneratedField;
6845
6846 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6847 write!(formatter, "expected one of: {:?}", &FIELDS)
6848 }
6849
6850 #[allow(unused_variables)]
6851 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6852 where
6853 E: serde::de::Error,
6854 {
6855 match value {
6856 "watermarkIndicesInJk" | "watermark_indices_in_jk" => Ok(GeneratedField::WatermarkIndicesInJk),
6857 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
6858 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6859 }
6860 }
6861 }
6862 deserializer.deserialize_identifier(GeneratedVisitor)
6863 }
6864 }
6865 struct GeneratedVisitor;
6866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6867 type Value = HashJoinWatermarkHandleDesc;
6868
6869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6870 formatter.write_str("struct stream_plan.HashJoinWatermarkHandleDesc")
6871 }
6872
6873 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinWatermarkHandleDesc, V::Error>
6874 where
6875 V: serde::de::MapAccess<'de>,
6876 {
6877 let mut watermark_indices_in_jk__ = None;
6878 let mut inequality_pairs__ = None;
6879 while let Some(k) = map_.next_key()? {
6880 match k {
6881 GeneratedField::WatermarkIndicesInJk => {
6882 if watermark_indices_in_jk__.is_some() {
6883 return Err(serde::de::Error::duplicate_field("watermarkIndicesInJk"));
6884 }
6885 watermark_indices_in_jk__ = Some(map_.next_value()?);
6886 }
6887 GeneratedField::InequalityPairs => {
6888 if inequality_pairs__.is_some() {
6889 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6890 }
6891 inequality_pairs__ = Some(map_.next_value()?);
6892 }
6893 }
6894 }
6895 Ok(HashJoinWatermarkHandleDesc {
6896 watermark_indices_in_jk: watermark_indices_in_jk__.unwrap_or_default(),
6897 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6898 })
6899 }
6900 }
6901 deserializer.deserialize_struct("stream_plan.HashJoinWatermarkHandleDesc", FIELDS, GeneratedVisitor)
6902 }
6903}
6904impl serde::Serialize for HopWindowNode {
6905 #[allow(deprecated)]
6906 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6907 where
6908 S: serde::Serializer,
6909 {
6910 use serde::ser::SerializeStruct;
6911 let mut len = 0;
6912 if self.time_col != 0 {
6913 len += 1;
6914 }
6915 if self.window_slide.is_some() {
6916 len += 1;
6917 }
6918 if self.window_size.is_some() {
6919 len += 1;
6920 }
6921 if !self.output_indices.is_empty() {
6922 len += 1;
6923 }
6924 if !self.window_start_exprs.is_empty() {
6925 len += 1;
6926 }
6927 if !self.window_end_exprs.is_empty() {
6928 len += 1;
6929 }
6930 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6931 if self.time_col != 0 {
6932 struct_ser.serialize_field("timeCol", &self.time_col)?;
6933 }
6934 if let Some(v) = self.window_slide.as_ref() {
6935 struct_ser.serialize_field("windowSlide", v)?;
6936 }
6937 if let Some(v) = self.window_size.as_ref() {
6938 struct_ser.serialize_field("windowSize", v)?;
6939 }
6940 if !self.output_indices.is_empty() {
6941 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6942 }
6943 if !self.window_start_exprs.is_empty() {
6944 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6945 }
6946 if !self.window_end_exprs.is_empty() {
6947 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6948 }
6949 struct_ser.end()
6950 }
6951}
6952impl<'de> serde::Deserialize<'de> for HopWindowNode {
6953 #[allow(deprecated)]
6954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6955 where
6956 D: serde::Deserializer<'de>,
6957 {
6958 const FIELDS: &[&str] = &[
6959 "time_col",
6960 "timeCol",
6961 "window_slide",
6962 "windowSlide",
6963 "window_size",
6964 "windowSize",
6965 "output_indices",
6966 "outputIndices",
6967 "window_start_exprs",
6968 "windowStartExprs",
6969 "window_end_exprs",
6970 "windowEndExprs",
6971 ];
6972
6973 #[allow(clippy::enum_variant_names)]
6974 enum GeneratedField {
6975 TimeCol,
6976 WindowSlide,
6977 WindowSize,
6978 OutputIndices,
6979 WindowStartExprs,
6980 WindowEndExprs,
6981 }
6982 impl<'de> serde::Deserialize<'de> for GeneratedField {
6983 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6984 where
6985 D: serde::Deserializer<'de>,
6986 {
6987 struct GeneratedVisitor;
6988
6989 impl serde::de::Visitor<'_> for GeneratedVisitor {
6990 type Value = GeneratedField;
6991
6992 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6993 write!(formatter, "expected one of: {:?}", &FIELDS)
6994 }
6995
6996 #[allow(unused_variables)]
6997 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6998 where
6999 E: serde::de::Error,
7000 {
7001 match value {
7002 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
7003 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
7004 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
7005 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
7006 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
7007 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
7008 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7009 }
7010 }
7011 }
7012 deserializer.deserialize_identifier(GeneratedVisitor)
7013 }
7014 }
7015 struct GeneratedVisitor;
7016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7017 type Value = HopWindowNode;
7018
7019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7020 formatter.write_str("struct stream_plan.HopWindowNode")
7021 }
7022
7023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
7024 where
7025 V: serde::de::MapAccess<'de>,
7026 {
7027 let mut time_col__ = None;
7028 let mut window_slide__ = None;
7029 let mut window_size__ = None;
7030 let mut output_indices__ = None;
7031 let mut window_start_exprs__ = None;
7032 let mut window_end_exprs__ = None;
7033 while let Some(k) = map_.next_key()? {
7034 match k {
7035 GeneratedField::TimeCol => {
7036 if time_col__.is_some() {
7037 return Err(serde::de::Error::duplicate_field("timeCol"));
7038 }
7039 time_col__ =
7040 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7041 ;
7042 }
7043 GeneratedField::WindowSlide => {
7044 if window_slide__.is_some() {
7045 return Err(serde::de::Error::duplicate_field("windowSlide"));
7046 }
7047 window_slide__ = map_.next_value()?;
7048 }
7049 GeneratedField::WindowSize => {
7050 if window_size__.is_some() {
7051 return Err(serde::de::Error::duplicate_field("windowSize"));
7052 }
7053 window_size__ = map_.next_value()?;
7054 }
7055 GeneratedField::OutputIndices => {
7056 if output_indices__.is_some() {
7057 return Err(serde::de::Error::duplicate_field("outputIndices"));
7058 }
7059 output_indices__ =
7060 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7061 .into_iter().map(|x| x.0).collect())
7062 ;
7063 }
7064 GeneratedField::WindowStartExprs => {
7065 if window_start_exprs__.is_some() {
7066 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
7067 }
7068 window_start_exprs__ = Some(map_.next_value()?);
7069 }
7070 GeneratedField::WindowEndExprs => {
7071 if window_end_exprs__.is_some() {
7072 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
7073 }
7074 window_end_exprs__ = Some(map_.next_value()?);
7075 }
7076 }
7077 }
7078 Ok(HopWindowNode {
7079 time_col: time_col__.unwrap_or_default(),
7080 window_slide: window_slide__,
7081 window_size: window_size__,
7082 output_indices: output_indices__.unwrap_or_default(),
7083 window_start_exprs: window_start_exprs__.unwrap_or_default(),
7084 window_end_exprs: window_end_exprs__.unwrap_or_default(),
7085 })
7086 }
7087 }
7088 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
7089 }
7090}
7091impl serde::Serialize for IcebergPkIndexCompactionContext {
7092 #[allow(deprecated)]
7093 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7094 where
7095 S: serde::Serializer,
7096 {
7097 use serde::ser::SerializeStruct;
7098 let mut len = 0;
7099 if self.sink_id != 0 {
7100 len += 1;
7101 }
7102 if self.task_id != 0 {
7103 len += 1;
7104 }
7105 if self.phase != 0 {
7106 len += 1;
7107 }
7108 if self.resolver_task_input.is_some() {
7109 len += 1;
7110 }
7111 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergPkIndexCompactionContext", len)?;
7112 if self.sink_id != 0 {
7113 struct_ser.serialize_field("sinkId", &self.sink_id)?;
7114 }
7115 if self.task_id != 0 {
7116 #[allow(clippy::needless_borrow)]
7117 #[allow(clippy::needless_borrows_for_generic_args)]
7118 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7119 }
7120 if self.phase != 0 {
7121 let v = iceberg_pk_index_compaction_context::Phase::try_from(self.phase)
7122 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.phase)))?;
7123 struct_ser.serialize_field("phase", &v)?;
7124 }
7125 if let Some(v) = self.resolver_task_input.as_ref() {
7126 struct_ser.serialize_field("resolverTaskInput", v)?;
7127 }
7128 struct_ser.end()
7129 }
7130}
7131impl<'de> serde::Deserialize<'de> for IcebergPkIndexCompactionContext {
7132 #[allow(deprecated)]
7133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7134 where
7135 D: serde::Deserializer<'de>,
7136 {
7137 const FIELDS: &[&str] = &[
7138 "sink_id",
7139 "sinkId",
7140 "task_id",
7141 "taskId",
7142 "phase",
7143 "resolver_task_input",
7144 "resolverTaskInput",
7145 ];
7146
7147 #[allow(clippy::enum_variant_names)]
7148 enum GeneratedField {
7149 SinkId,
7150 TaskId,
7151 Phase,
7152 ResolverTaskInput,
7153 }
7154 impl<'de> serde::Deserialize<'de> for GeneratedField {
7155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7156 where
7157 D: serde::Deserializer<'de>,
7158 {
7159 struct GeneratedVisitor;
7160
7161 impl serde::de::Visitor<'_> for GeneratedVisitor {
7162 type Value = GeneratedField;
7163
7164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7165 write!(formatter, "expected one of: {:?}", &FIELDS)
7166 }
7167
7168 #[allow(unused_variables)]
7169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7170 where
7171 E: serde::de::Error,
7172 {
7173 match value {
7174 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
7175 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7176 "phase" => Ok(GeneratedField::Phase),
7177 "resolverTaskInput" | "resolver_task_input" => Ok(GeneratedField::ResolverTaskInput),
7178 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7179 }
7180 }
7181 }
7182 deserializer.deserialize_identifier(GeneratedVisitor)
7183 }
7184 }
7185 struct GeneratedVisitor;
7186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7187 type Value = IcebergPkIndexCompactionContext;
7188
7189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7190 formatter.write_str("struct stream_plan.IcebergPkIndexCompactionContext")
7191 }
7192
7193 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergPkIndexCompactionContext, V::Error>
7194 where
7195 V: serde::de::MapAccess<'de>,
7196 {
7197 let mut sink_id__ = None;
7198 let mut task_id__ = None;
7199 let mut phase__ = None;
7200 let mut resolver_task_input__ = None;
7201 while let Some(k) = map_.next_key()? {
7202 match k {
7203 GeneratedField::SinkId => {
7204 if sink_id__.is_some() {
7205 return Err(serde::de::Error::duplicate_field("sinkId"));
7206 }
7207 sink_id__ =
7208 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7209 ;
7210 }
7211 GeneratedField::TaskId => {
7212 if task_id__.is_some() {
7213 return Err(serde::de::Error::duplicate_field("taskId"));
7214 }
7215 task_id__ =
7216 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7217 ;
7218 }
7219 GeneratedField::Phase => {
7220 if phase__.is_some() {
7221 return Err(serde::de::Error::duplicate_field("phase"));
7222 }
7223 phase__ = Some(map_.next_value::<iceberg_pk_index_compaction_context::Phase>()? as i32);
7224 }
7225 GeneratedField::ResolverTaskInput => {
7226 if resolver_task_input__.is_some() {
7227 return Err(serde::de::Error::duplicate_field("resolverTaskInput"));
7228 }
7229 resolver_task_input__ = map_.next_value()?;
7230 }
7231 }
7232 }
7233 Ok(IcebergPkIndexCompactionContext {
7234 sink_id: sink_id__.unwrap_or_default(),
7235 task_id: task_id__.unwrap_or_default(),
7236 phase: phase__.unwrap_or_default(),
7237 resolver_task_input: resolver_task_input__,
7238 })
7239 }
7240 }
7241 deserializer.deserialize_struct("stream_plan.IcebergPkIndexCompactionContext", FIELDS, GeneratedVisitor)
7242 }
7243}
7244impl serde::Serialize for iceberg_pk_index_compaction_context::Phase {
7245 #[allow(deprecated)]
7246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7247 where
7248 S: serde::Serializer,
7249 {
7250 let variant = match self {
7251 Self::Unspecified => "PHASE_UNSPECIFIED",
7252 Self::Begin => "PHASE_BEGIN",
7253 Self::End => "PHASE_END",
7254 };
7255 serializer.serialize_str(variant)
7256 }
7257}
7258impl<'de> serde::Deserialize<'de> for iceberg_pk_index_compaction_context::Phase {
7259 #[allow(deprecated)]
7260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7261 where
7262 D: serde::Deserializer<'de>,
7263 {
7264 const FIELDS: &[&str] = &[
7265 "PHASE_UNSPECIFIED",
7266 "PHASE_BEGIN",
7267 "PHASE_END",
7268 ];
7269
7270 struct GeneratedVisitor;
7271
7272 impl serde::de::Visitor<'_> for GeneratedVisitor {
7273 type Value = iceberg_pk_index_compaction_context::Phase;
7274
7275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7276 write!(formatter, "expected one of: {:?}", &FIELDS)
7277 }
7278
7279 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7280 where
7281 E: serde::de::Error,
7282 {
7283 i32::try_from(v)
7284 .ok()
7285 .and_then(|x| x.try_into().ok())
7286 .ok_or_else(|| {
7287 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7288 })
7289 }
7290
7291 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7292 where
7293 E: serde::de::Error,
7294 {
7295 i32::try_from(v)
7296 .ok()
7297 .and_then(|x| x.try_into().ok())
7298 .ok_or_else(|| {
7299 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7300 })
7301 }
7302
7303 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7304 where
7305 E: serde::de::Error,
7306 {
7307 match value {
7308 "PHASE_UNSPECIFIED" => Ok(iceberg_pk_index_compaction_context::Phase::Unspecified),
7309 "PHASE_BEGIN" => Ok(iceberg_pk_index_compaction_context::Phase::Begin),
7310 "PHASE_END" => Ok(iceberg_pk_index_compaction_context::Phase::End),
7311 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7312 }
7313 }
7314 }
7315 deserializer.deserialize_any(GeneratedVisitor)
7316 }
7317}
7318impl serde::Serialize for iceberg_pk_index_compaction_context::ResolverTaskInput {
7319 #[allow(deprecated)]
7320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7321 where
7322 S: serde::Serializer,
7323 {
7324 use serde::ser::SerializeStruct;
7325 let mut len = 0;
7326 if !self.output_data_file_paths.is_empty() {
7327 len += 1;
7328 }
7329 if !self.input_data_file_paths.is_empty() {
7330 len += 1;
7331 }
7332 if self.read_snapshot_id != 0 {
7333 len += 1;
7334 }
7335 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergPkIndexCompactionContext.ResolverTaskInput", len)?;
7336 if !self.output_data_file_paths.is_empty() {
7337 struct_ser.serialize_field("outputDataFilePaths", &self.output_data_file_paths)?;
7338 }
7339 if !self.input_data_file_paths.is_empty() {
7340 struct_ser.serialize_field("inputDataFilePaths", &self.input_data_file_paths)?;
7341 }
7342 if self.read_snapshot_id != 0 {
7343 #[allow(clippy::needless_borrow)]
7344 #[allow(clippy::needless_borrows_for_generic_args)]
7345 struct_ser.serialize_field("readSnapshotId", ToString::to_string(&self.read_snapshot_id).as_str())?;
7346 }
7347 struct_ser.end()
7348 }
7349}
7350impl<'de> serde::Deserialize<'de> for iceberg_pk_index_compaction_context::ResolverTaskInput {
7351 #[allow(deprecated)]
7352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7353 where
7354 D: serde::Deserializer<'de>,
7355 {
7356 const FIELDS: &[&str] = &[
7357 "output_data_file_paths",
7358 "outputDataFilePaths",
7359 "input_data_file_paths",
7360 "inputDataFilePaths",
7361 "read_snapshot_id",
7362 "readSnapshotId",
7363 ];
7364
7365 #[allow(clippy::enum_variant_names)]
7366 enum GeneratedField {
7367 OutputDataFilePaths,
7368 InputDataFilePaths,
7369 ReadSnapshotId,
7370 }
7371 impl<'de> serde::Deserialize<'de> for GeneratedField {
7372 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7373 where
7374 D: serde::Deserializer<'de>,
7375 {
7376 struct GeneratedVisitor;
7377
7378 impl serde::de::Visitor<'_> for GeneratedVisitor {
7379 type Value = GeneratedField;
7380
7381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7382 write!(formatter, "expected one of: {:?}", &FIELDS)
7383 }
7384
7385 #[allow(unused_variables)]
7386 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7387 where
7388 E: serde::de::Error,
7389 {
7390 match value {
7391 "outputDataFilePaths" | "output_data_file_paths" => Ok(GeneratedField::OutputDataFilePaths),
7392 "inputDataFilePaths" | "input_data_file_paths" => Ok(GeneratedField::InputDataFilePaths),
7393 "readSnapshotId" | "read_snapshot_id" => Ok(GeneratedField::ReadSnapshotId),
7394 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7395 }
7396 }
7397 }
7398 deserializer.deserialize_identifier(GeneratedVisitor)
7399 }
7400 }
7401 struct GeneratedVisitor;
7402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7403 type Value = iceberg_pk_index_compaction_context::ResolverTaskInput;
7404
7405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7406 formatter.write_str("struct stream_plan.IcebergPkIndexCompactionContext.ResolverTaskInput")
7407 }
7408
7409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<iceberg_pk_index_compaction_context::ResolverTaskInput, V::Error>
7410 where
7411 V: serde::de::MapAccess<'de>,
7412 {
7413 let mut output_data_file_paths__ = None;
7414 let mut input_data_file_paths__ = None;
7415 let mut read_snapshot_id__ = None;
7416 while let Some(k) = map_.next_key()? {
7417 match k {
7418 GeneratedField::OutputDataFilePaths => {
7419 if output_data_file_paths__.is_some() {
7420 return Err(serde::de::Error::duplicate_field("outputDataFilePaths"));
7421 }
7422 output_data_file_paths__ = Some(map_.next_value()?);
7423 }
7424 GeneratedField::InputDataFilePaths => {
7425 if input_data_file_paths__.is_some() {
7426 return Err(serde::de::Error::duplicate_field("inputDataFilePaths"));
7427 }
7428 input_data_file_paths__ = Some(map_.next_value()?);
7429 }
7430 GeneratedField::ReadSnapshotId => {
7431 if read_snapshot_id__.is_some() {
7432 return Err(serde::de::Error::duplicate_field("readSnapshotId"));
7433 }
7434 read_snapshot_id__ =
7435 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7436 ;
7437 }
7438 }
7439 }
7440 Ok(iceberg_pk_index_compaction_context::ResolverTaskInput {
7441 output_data_file_paths: output_data_file_paths__.unwrap_or_default(),
7442 input_data_file_paths: input_data_file_paths__.unwrap_or_default(),
7443 read_snapshot_id: read_snapshot_id__.unwrap_or_default(),
7444 })
7445 }
7446 }
7447 deserializer.deserialize_struct("stream_plan.IcebergPkIndexCompactionContext.ResolverTaskInput", FIELDS, GeneratedVisitor)
7448 }
7449}
7450impl serde::Serialize for IcebergWithPkIndexPositionDeleteMergerNode {
7451 #[allow(deprecated)]
7452 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7453 where
7454 S: serde::Serializer,
7455 {
7456 use serde::ser::SerializeStruct;
7457 let mut len = 0;
7458 if self.sink_desc.is_some() {
7459 len += 1;
7460 }
7461 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", len)?;
7462 if let Some(v) = self.sink_desc.as_ref() {
7463 struct_ser.serialize_field("sinkDesc", v)?;
7464 }
7465 struct_ser.end()
7466 }
7467}
7468impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexPositionDeleteMergerNode {
7469 #[allow(deprecated)]
7470 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7471 where
7472 D: serde::Deserializer<'de>,
7473 {
7474 const FIELDS: &[&str] = &[
7475 "sink_desc",
7476 "sinkDesc",
7477 ];
7478
7479 #[allow(clippy::enum_variant_names)]
7480 enum GeneratedField {
7481 SinkDesc,
7482 }
7483 impl<'de> serde::Deserialize<'de> for GeneratedField {
7484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7485 where
7486 D: serde::Deserializer<'de>,
7487 {
7488 struct GeneratedVisitor;
7489
7490 impl serde::de::Visitor<'_> for GeneratedVisitor {
7491 type Value = GeneratedField;
7492
7493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7494 write!(formatter, "expected one of: {:?}", &FIELDS)
7495 }
7496
7497 #[allow(unused_variables)]
7498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7499 where
7500 E: serde::de::Error,
7501 {
7502 match value {
7503 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
7504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7505 }
7506 }
7507 }
7508 deserializer.deserialize_identifier(GeneratedVisitor)
7509 }
7510 }
7511 struct GeneratedVisitor;
7512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7513 type Value = IcebergWithPkIndexPositionDeleteMergerNode;
7514
7515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7516 formatter.write_str("struct stream_plan.IcebergWithPkIndexPositionDeleteMergerNode")
7517 }
7518
7519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexPositionDeleteMergerNode, V::Error>
7520 where
7521 V: serde::de::MapAccess<'de>,
7522 {
7523 let mut sink_desc__ = None;
7524 while let Some(k) = map_.next_key()? {
7525 match k {
7526 GeneratedField::SinkDesc => {
7527 if sink_desc__.is_some() {
7528 return Err(serde::de::Error::duplicate_field("sinkDesc"));
7529 }
7530 sink_desc__ = map_.next_value()?;
7531 }
7532 }
7533 }
7534 Ok(IcebergWithPkIndexPositionDeleteMergerNode {
7535 sink_desc: sink_desc__,
7536 })
7537 }
7538 }
7539 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", FIELDS, GeneratedVisitor)
7540 }
7541}
7542impl serde::Serialize for IcebergWithPkIndexWriterNode {
7543 #[allow(deprecated)]
7544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7545 where
7546 S: serde::Serializer,
7547 {
7548 use serde::ser::SerializeStruct;
7549 let mut len = 0;
7550 if self.sink_desc.is_some() {
7551 len += 1;
7552 }
7553 if self.pk_index_table.is_some() {
7554 len += 1;
7555 }
7556 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexWriterNode", len)?;
7557 if let Some(v) = self.sink_desc.as_ref() {
7558 struct_ser.serialize_field("sinkDesc", v)?;
7559 }
7560 if let Some(v) = self.pk_index_table.as_ref() {
7561 struct_ser.serialize_field("pkIndexTable", v)?;
7562 }
7563 struct_ser.end()
7564 }
7565}
7566impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexWriterNode {
7567 #[allow(deprecated)]
7568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7569 where
7570 D: serde::Deserializer<'de>,
7571 {
7572 const FIELDS: &[&str] = &[
7573 "sink_desc",
7574 "sinkDesc",
7575 "pk_index_table",
7576 "pkIndexTable",
7577 ];
7578
7579 #[allow(clippy::enum_variant_names)]
7580 enum GeneratedField {
7581 SinkDesc,
7582 PkIndexTable,
7583 }
7584 impl<'de> serde::Deserialize<'de> for GeneratedField {
7585 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7586 where
7587 D: serde::Deserializer<'de>,
7588 {
7589 struct GeneratedVisitor;
7590
7591 impl serde::de::Visitor<'_> for GeneratedVisitor {
7592 type Value = GeneratedField;
7593
7594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7595 write!(formatter, "expected one of: {:?}", &FIELDS)
7596 }
7597
7598 #[allow(unused_variables)]
7599 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7600 where
7601 E: serde::de::Error,
7602 {
7603 match value {
7604 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
7605 "pkIndexTable" | "pk_index_table" => Ok(GeneratedField::PkIndexTable),
7606 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7607 }
7608 }
7609 }
7610 deserializer.deserialize_identifier(GeneratedVisitor)
7611 }
7612 }
7613 struct GeneratedVisitor;
7614 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7615 type Value = IcebergWithPkIndexWriterNode;
7616
7617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7618 formatter.write_str("struct stream_plan.IcebergWithPkIndexWriterNode")
7619 }
7620
7621 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexWriterNode, V::Error>
7622 where
7623 V: serde::de::MapAccess<'de>,
7624 {
7625 let mut sink_desc__ = None;
7626 let mut pk_index_table__ = None;
7627 while let Some(k) = map_.next_key()? {
7628 match k {
7629 GeneratedField::SinkDesc => {
7630 if sink_desc__.is_some() {
7631 return Err(serde::de::Error::duplicate_field("sinkDesc"));
7632 }
7633 sink_desc__ = map_.next_value()?;
7634 }
7635 GeneratedField::PkIndexTable => {
7636 if pk_index_table__.is_some() {
7637 return Err(serde::de::Error::duplicate_field("pkIndexTable"));
7638 }
7639 pk_index_table__ = map_.next_value()?;
7640 }
7641 }
7642 }
7643 Ok(IcebergWithPkIndexWriterNode {
7644 sink_desc: sink_desc__,
7645 pk_index_table: pk_index_table__,
7646 })
7647 }
7648 }
7649 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexWriterNode", FIELDS, GeneratedVisitor)
7650 }
7651}
7652impl serde::Serialize for InequalityPair {
7653 #[allow(deprecated)]
7654 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7655 where
7656 S: serde::Serializer,
7657 {
7658 use serde::ser::SerializeStruct;
7659 let mut len = 0;
7660 if self.key_required_larger != 0 {
7661 len += 1;
7662 }
7663 if self.key_required_smaller != 0 {
7664 len += 1;
7665 }
7666 if self.clean_state {
7667 len += 1;
7668 }
7669 if self.delta_expression.is_some() {
7670 len += 1;
7671 }
7672 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
7673 if self.key_required_larger != 0 {
7674 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
7675 }
7676 if self.key_required_smaller != 0 {
7677 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
7678 }
7679 if self.clean_state {
7680 struct_ser.serialize_field("cleanState", &self.clean_state)?;
7681 }
7682 if let Some(v) = self.delta_expression.as_ref() {
7683 struct_ser.serialize_field("deltaExpression", v)?;
7684 }
7685 struct_ser.end()
7686 }
7687}
7688impl<'de> serde::Deserialize<'de> for InequalityPair {
7689 #[allow(deprecated)]
7690 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7691 where
7692 D: serde::Deserializer<'de>,
7693 {
7694 const FIELDS: &[&str] = &[
7695 "key_required_larger",
7696 "keyRequiredLarger",
7697 "key_required_smaller",
7698 "keyRequiredSmaller",
7699 "clean_state",
7700 "cleanState",
7701 "delta_expression",
7702 "deltaExpression",
7703 ];
7704
7705 #[allow(clippy::enum_variant_names)]
7706 enum GeneratedField {
7707 KeyRequiredLarger,
7708 KeyRequiredSmaller,
7709 CleanState,
7710 DeltaExpression,
7711 }
7712 impl<'de> serde::Deserialize<'de> for GeneratedField {
7713 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7714 where
7715 D: serde::Deserializer<'de>,
7716 {
7717 struct GeneratedVisitor;
7718
7719 impl serde::de::Visitor<'_> for GeneratedVisitor {
7720 type Value = GeneratedField;
7721
7722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7723 write!(formatter, "expected one of: {:?}", &FIELDS)
7724 }
7725
7726 #[allow(unused_variables)]
7727 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7728 where
7729 E: serde::de::Error,
7730 {
7731 match value {
7732 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
7733 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
7734 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
7735 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
7736 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7737 }
7738 }
7739 }
7740 deserializer.deserialize_identifier(GeneratedVisitor)
7741 }
7742 }
7743 struct GeneratedVisitor;
7744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7745 type Value = InequalityPair;
7746
7747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7748 formatter.write_str("struct stream_plan.InequalityPair")
7749 }
7750
7751 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
7752 where
7753 V: serde::de::MapAccess<'de>,
7754 {
7755 let mut key_required_larger__ = None;
7756 let mut key_required_smaller__ = None;
7757 let mut clean_state__ = None;
7758 let mut delta_expression__ = None;
7759 while let Some(k) = map_.next_key()? {
7760 match k {
7761 GeneratedField::KeyRequiredLarger => {
7762 if key_required_larger__.is_some() {
7763 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
7764 }
7765 key_required_larger__ =
7766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7767 ;
7768 }
7769 GeneratedField::KeyRequiredSmaller => {
7770 if key_required_smaller__.is_some() {
7771 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
7772 }
7773 key_required_smaller__ =
7774 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7775 ;
7776 }
7777 GeneratedField::CleanState => {
7778 if clean_state__.is_some() {
7779 return Err(serde::de::Error::duplicate_field("cleanState"));
7780 }
7781 clean_state__ = Some(map_.next_value()?);
7782 }
7783 GeneratedField::DeltaExpression => {
7784 if delta_expression__.is_some() {
7785 return Err(serde::de::Error::duplicate_field("deltaExpression"));
7786 }
7787 delta_expression__ = map_.next_value()?;
7788 }
7789 }
7790 }
7791 Ok(InequalityPair {
7792 key_required_larger: key_required_larger__.unwrap_or_default(),
7793 key_required_smaller: key_required_smaller__.unwrap_or_default(),
7794 clean_state: clean_state__.unwrap_or_default(),
7795 delta_expression: delta_expression__,
7796 })
7797 }
7798 }
7799 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
7800 }
7801}
7802impl serde::Serialize for InequalityPairV2 {
7803 #[allow(deprecated)]
7804 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7805 where
7806 S: serde::Serializer,
7807 {
7808 use serde::ser::SerializeStruct;
7809 let mut len = 0;
7810 if self.left_idx != 0 {
7811 len += 1;
7812 }
7813 if self.right_idx != 0 {
7814 len += 1;
7815 }
7816 if self.clean_left_state {
7817 len += 1;
7818 }
7819 if self.clean_right_state {
7820 len += 1;
7821 }
7822 if self.op != 0 {
7823 len += 1;
7824 }
7825 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
7826 if self.left_idx != 0 {
7827 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
7828 }
7829 if self.right_idx != 0 {
7830 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
7831 }
7832 if self.clean_left_state {
7833 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
7834 }
7835 if self.clean_right_state {
7836 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
7837 }
7838 if self.op != 0 {
7839 let v = InequalityType::try_from(self.op)
7840 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
7841 struct_ser.serialize_field("op", &v)?;
7842 }
7843 struct_ser.end()
7844 }
7845}
7846impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
7847 #[allow(deprecated)]
7848 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7849 where
7850 D: serde::Deserializer<'de>,
7851 {
7852 const FIELDS: &[&str] = &[
7853 "left_idx",
7854 "leftIdx",
7855 "right_idx",
7856 "rightIdx",
7857 "clean_left_state",
7858 "cleanLeftState",
7859 "clean_right_state",
7860 "cleanRightState",
7861 "op",
7862 ];
7863
7864 #[allow(clippy::enum_variant_names)]
7865 enum GeneratedField {
7866 LeftIdx,
7867 RightIdx,
7868 CleanLeftState,
7869 CleanRightState,
7870 Op,
7871 }
7872 impl<'de> serde::Deserialize<'de> for GeneratedField {
7873 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7874 where
7875 D: serde::Deserializer<'de>,
7876 {
7877 struct GeneratedVisitor;
7878
7879 impl serde::de::Visitor<'_> for GeneratedVisitor {
7880 type Value = GeneratedField;
7881
7882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7883 write!(formatter, "expected one of: {:?}", &FIELDS)
7884 }
7885
7886 #[allow(unused_variables)]
7887 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7888 where
7889 E: serde::de::Error,
7890 {
7891 match value {
7892 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
7893 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
7894 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
7895 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
7896 "op" => Ok(GeneratedField::Op),
7897 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7898 }
7899 }
7900 }
7901 deserializer.deserialize_identifier(GeneratedVisitor)
7902 }
7903 }
7904 struct GeneratedVisitor;
7905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7906 type Value = InequalityPairV2;
7907
7908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7909 formatter.write_str("struct stream_plan.InequalityPairV2")
7910 }
7911
7912 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
7913 where
7914 V: serde::de::MapAccess<'de>,
7915 {
7916 let mut left_idx__ = None;
7917 let mut right_idx__ = None;
7918 let mut clean_left_state__ = None;
7919 let mut clean_right_state__ = None;
7920 let mut op__ = None;
7921 while let Some(k) = map_.next_key()? {
7922 match k {
7923 GeneratedField::LeftIdx => {
7924 if left_idx__.is_some() {
7925 return Err(serde::de::Error::duplicate_field("leftIdx"));
7926 }
7927 left_idx__ =
7928 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7929 ;
7930 }
7931 GeneratedField::RightIdx => {
7932 if right_idx__.is_some() {
7933 return Err(serde::de::Error::duplicate_field("rightIdx"));
7934 }
7935 right_idx__ =
7936 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7937 ;
7938 }
7939 GeneratedField::CleanLeftState => {
7940 if clean_left_state__.is_some() {
7941 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
7942 }
7943 clean_left_state__ = Some(map_.next_value()?);
7944 }
7945 GeneratedField::CleanRightState => {
7946 if clean_right_state__.is_some() {
7947 return Err(serde::de::Error::duplicate_field("cleanRightState"));
7948 }
7949 clean_right_state__ = Some(map_.next_value()?);
7950 }
7951 GeneratedField::Op => {
7952 if op__.is_some() {
7953 return Err(serde::de::Error::duplicate_field("op"));
7954 }
7955 op__ = Some(map_.next_value::<InequalityType>()? as i32);
7956 }
7957 }
7958 }
7959 Ok(InequalityPairV2 {
7960 left_idx: left_idx__.unwrap_or_default(),
7961 right_idx: right_idx__.unwrap_or_default(),
7962 clean_left_state: clean_left_state__.unwrap_or_default(),
7963 clean_right_state: clean_right_state__.unwrap_or_default(),
7964 op: op__.unwrap_or_default(),
7965 })
7966 }
7967 }
7968 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
7969 }
7970}
7971impl serde::Serialize for InequalityType {
7972 #[allow(deprecated)]
7973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7974 where
7975 S: serde::Serializer,
7976 {
7977 let variant = match self {
7978 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
7979 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
7980 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7981 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
7982 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7983 };
7984 serializer.serialize_str(variant)
7985 }
7986}
7987impl<'de> serde::Deserialize<'de> for InequalityType {
7988 #[allow(deprecated)]
7989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7990 where
7991 D: serde::Deserializer<'de>,
7992 {
7993 const FIELDS: &[&str] = &[
7994 "INEQUALITY_TYPE_UNSPECIFIED",
7995 "INEQUALITY_TYPE_LESS_THAN",
7996 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7997 "INEQUALITY_TYPE_GREATER_THAN",
7998 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7999 ];
8000
8001 struct GeneratedVisitor;
8002
8003 impl serde::de::Visitor<'_> for GeneratedVisitor {
8004 type Value = InequalityType;
8005
8006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8007 write!(formatter, "expected one of: {:?}", &FIELDS)
8008 }
8009
8010 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8011 where
8012 E: serde::de::Error,
8013 {
8014 i32::try_from(v)
8015 .ok()
8016 .and_then(|x| x.try_into().ok())
8017 .ok_or_else(|| {
8018 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8019 })
8020 }
8021
8022 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8023 where
8024 E: serde::de::Error,
8025 {
8026 i32::try_from(v)
8027 .ok()
8028 .and_then(|x| x.try_into().ok())
8029 .ok_or_else(|| {
8030 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8031 })
8032 }
8033
8034 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8035 where
8036 E: serde::de::Error,
8037 {
8038 match value {
8039 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
8040 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
8041 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
8042 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
8043 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
8044 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8045 }
8046 }
8047 }
8048 deserializer.deserialize_any(GeneratedVisitor)
8049 }
8050}
8051impl serde::Serialize for InjectSourceOffsetsMutation {
8052 #[allow(deprecated)]
8053 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8054 where
8055 S: serde::Serializer,
8056 {
8057 use serde::ser::SerializeStruct;
8058 let mut len = 0;
8059 if self.source_id != 0 {
8060 len += 1;
8061 }
8062 if !self.split_offsets.is_empty() {
8063 len += 1;
8064 }
8065 let mut struct_ser = serializer.serialize_struct("stream_plan.InjectSourceOffsetsMutation", len)?;
8066 if self.source_id != 0 {
8067 struct_ser.serialize_field("sourceId", &self.source_id)?;
8068 }
8069 if !self.split_offsets.is_empty() {
8070 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
8071 }
8072 struct_ser.end()
8073 }
8074}
8075impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsMutation {
8076 #[allow(deprecated)]
8077 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8078 where
8079 D: serde::Deserializer<'de>,
8080 {
8081 const FIELDS: &[&str] = &[
8082 "source_id",
8083 "sourceId",
8084 "split_offsets",
8085 "splitOffsets",
8086 ];
8087
8088 #[allow(clippy::enum_variant_names)]
8089 enum GeneratedField {
8090 SourceId,
8091 SplitOffsets,
8092 }
8093 impl<'de> serde::Deserialize<'de> for GeneratedField {
8094 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8095 where
8096 D: serde::Deserializer<'de>,
8097 {
8098 struct GeneratedVisitor;
8099
8100 impl serde::de::Visitor<'_> for GeneratedVisitor {
8101 type Value = GeneratedField;
8102
8103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8104 write!(formatter, "expected one of: {:?}", &FIELDS)
8105 }
8106
8107 #[allow(unused_variables)]
8108 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8109 where
8110 E: serde::de::Error,
8111 {
8112 match value {
8113 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8114 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
8115 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8116 }
8117 }
8118 }
8119 deserializer.deserialize_identifier(GeneratedVisitor)
8120 }
8121 }
8122 struct GeneratedVisitor;
8123 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8124 type Value = InjectSourceOffsetsMutation;
8125
8126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8127 formatter.write_str("struct stream_plan.InjectSourceOffsetsMutation")
8128 }
8129
8130 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsMutation, V::Error>
8131 where
8132 V: serde::de::MapAccess<'de>,
8133 {
8134 let mut source_id__ = None;
8135 let mut split_offsets__ = None;
8136 while let Some(k) = map_.next_key()? {
8137 match k {
8138 GeneratedField::SourceId => {
8139 if source_id__.is_some() {
8140 return Err(serde::de::Error::duplicate_field("sourceId"));
8141 }
8142 source_id__ =
8143 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8144 ;
8145 }
8146 GeneratedField::SplitOffsets => {
8147 if split_offsets__.is_some() {
8148 return Err(serde::de::Error::duplicate_field("splitOffsets"));
8149 }
8150 split_offsets__ = Some(
8151 map_.next_value::<std::collections::HashMap<_, _>>()?
8152 );
8153 }
8154 }
8155 }
8156 Ok(InjectSourceOffsetsMutation {
8157 source_id: source_id__.unwrap_or_default(),
8158 split_offsets: split_offsets__.unwrap_or_default(),
8159 })
8160 }
8161 }
8162 deserializer.deserialize_struct("stream_plan.InjectSourceOffsetsMutation", FIELDS, GeneratedVisitor)
8163 }
8164}
8165impl serde::Serialize for JoinEncodingType {
8166 #[allow(deprecated)]
8167 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8168 where
8169 S: serde::Serializer,
8170 {
8171 let variant = match self {
8172 Self::Unspecified => "UNSPECIFIED",
8173 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
8174 Self::CpuOptimized => "CPU_OPTIMIZED",
8175 };
8176 serializer.serialize_str(variant)
8177 }
8178}
8179impl<'de> serde::Deserialize<'de> for JoinEncodingType {
8180 #[allow(deprecated)]
8181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8182 where
8183 D: serde::Deserializer<'de>,
8184 {
8185 const FIELDS: &[&str] = &[
8186 "UNSPECIFIED",
8187 "MEMORY_OPTIMIZED",
8188 "CPU_OPTIMIZED",
8189 ];
8190
8191 struct GeneratedVisitor;
8192
8193 impl serde::de::Visitor<'_> for GeneratedVisitor {
8194 type Value = JoinEncodingType;
8195
8196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8197 write!(formatter, "expected one of: {:?}", &FIELDS)
8198 }
8199
8200 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8201 where
8202 E: serde::de::Error,
8203 {
8204 i32::try_from(v)
8205 .ok()
8206 .and_then(|x| x.try_into().ok())
8207 .ok_or_else(|| {
8208 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8209 })
8210 }
8211
8212 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8213 where
8214 E: serde::de::Error,
8215 {
8216 i32::try_from(v)
8217 .ok()
8218 .and_then(|x| x.try_into().ok())
8219 .ok_or_else(|| {
8220 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8221 })
8222 }
8223
8224 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8225 where
8226 E: serde::de::Error,
8227 {
8228 match value {
8229 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
8230 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
8231 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
8232 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8233 }
8234 }
8235 }
8236 deserializer.deserialize_any(GeneratedVisitor)
8237 }
8238}
8239impl serde::Serialize for JoinKeyWatermarkIndex {
8240 #[allow(deprecated)]
8241 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8242 where
8243 S: serde::Serializer,
8244 {
8245 use serde::ser::SerializeStruct;
8246 let mut len = 0;
8247 if self.index != 0 {
8248 len += 1;
8249 }
8250 if self.do_state_cleaning {
8251 len += 1;
8252 }
8253 let mut struct_ser = serializer.serialize_struct("stream_plan.JoinKeyWatermarkIndex", len)?;
8254 if self.index != 0 {
8255 struct_ser.serialize_field("index", &self.index)?;
8256 }
8257 if self.do_state_cleaning {
8258 struct_ser.serialize_field("doStateCleaning", &self.do_state_cleaning)?;
8259 }
8260 struct_ser.end()
8261 }
8262}
8263impl<'de> serde::Deserialize<'de> for JoinKeyWatermarkIndex {
8264 #[allow(deprecated)]
8265 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8266 where
8267 D: serde::Deserializer<'de>,
8268 {
8269 const FIELDS: &[&str] = &[
8270 "index",
8271 "do_state_cleaning",
8272 "doStateCleaning",
8273 ];
8274
8275 #[allow(clippy::enum_variant_names)]
8276 enum GeneratedField {
8277 Index,
8278 DoStateCleaning,
8279 }
8280 impl<'de> serde::Deserialize<'de> for GeneratedField {
8281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8282 where
8283 D: serde::Deserializer<'de>,
8284 {
8285 struct GeneratedVisitor;
8286
8287 impl serde::de::Visitor<'_> for GeneratedVisitor {
8288 type Value = GeneratedField;
8289
8290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8291 write!(formatter, "expected one of: {:?}", &FIELDS)
8292 }
8293
8294 #[allow(unused_variables)]
8295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8296 where
8297 E: serde::de::Error,
8298 {
8299 match value {
8300 "index" => Ok(GeneratedField::Index),
8301 "doStateCleaning" | "do_state_cleaning" => Ok(GeneratedField::DoStateCleaning),
8302 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8303 }
8304 }
8305 }
8306 deserializer.deserialize_identifier(GeneratedVisitor)
8307 }
8308 }
8309 struct GeneratedVisitor;
8310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8311 type Value = JoinKeyWatermarkIndex;
8312
8313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8314 formatter.write_str("struct stream_plan.JoinKeyWatermarkIndex")
8315 }
8316
8317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<JoinKeyWatermarkIndex, V::Error>
8318 where
8319 V: serde::de::MapAccess<'de>,
8320 {
8321 let mut index__ = None;
8322 let mut do_state_cleaning__ = None;
8323 while let Some(k) = map_.next_key()? {
8324 match k {
8325 GeneratedField::Index => {
8326 if index__.is_some() {
8327 return Err(serde::de::Error::duplicate_field("index"));
8328 }
8329 index__ =
8330 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8331 ;
8332 }
8333 GeneratedField::DoStateCleaning => {
8334 if do_state_cleaning__.is_some() {
8335 return Err(serde::de::Error::duplicate_field("doStateCleaning"));
8336 }
8337 do_state_cleaning__ = Some(map_.next_value()?);
8338 }
8339 }
8340 }
8341 Ok(JoinKeyWatermarkIndex {
8342 index: index__.unwrap_or_default(),
8343 do_state_cleaning: do_state_cleaning__.unwrap_or_default(),
8344 })
8345 }
8346 }
8347 deserializer.deserialize_struct("stream_plan.JoinKeyWatermarkIndex", FIELDS, GeneratedVisitor)
8348 }
8349}
8350impl serde::Serialize for ListFinishMutation {
8351 #[allow(deprecated)]
8352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8353 where
8354 S: serde::Serializer,
8355 {
8356 use serde::ser::SerializeStruct;
8357 let mut len = 0;
8358 if self.associated_source_id != 0 {
8359 len += 1;
8360 }
8361 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
8362 if self.associated_source_id != 0 {
8363 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8364 }
8365 struct_ser.end()
8366 }
8367}
8368impl<'de> serde::Deserialize<'de> for ListFinishMutation {
8369 #[allow(deprecated)]
8370 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8371 where
8372 D: serde::Deserializer<'de>,
8373 {
8374 const FIELDS: &[&str] = &[
8375 "associated_source_id",
8376 "associatedSourceId",
8377 ];
8378
8379 #[allow(clippy::enum_variant_names)]
8380 enum GeneratedField {
8381 AssociatedSourceId,
8382 }
8383 impl<'de> serde::Deserialize<'de> for GeneratedField {
8384 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8385 where
8386 D: serde::Deserializer<'de>,
8387 {
8388 struct GeneratedVisitor;
8389
8390 impl serde::de::Visitor<'_> for GeneratedVisitor {
8391 type Value = GeneratedField;
8392
8393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8394 write!(formatter, "expected one of: {:?}", &FIELDS)
8395 }
8396
8397 #[allow(unused_variables)]
8398 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8399 where
8400 E: serde::de::Error,
8401 {
8402 match value {
8403 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8404 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8405 }
8406 }
8407 }
8408 deserializer.deserialize_identifier(GeneratedVisitor)
8409 }
8410 }
8411 struct GeneratedVisitor;
8412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8413 type Value = ListFinishMutation;
8414
8415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8416 formatter.write_str("struct stream_plan.ListFinishMutation")
8417 }
8418
8419 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
8420 where
8421 V: serde::de::MapAccess<'de>,
8422 {
8423 let mut associated_source_id__ = None;
8424 while let Some(k) = map_.next_key()? {
8425 match k {
8426 GeneratedField::AssociatedSourceId => {
8427 if associated_source_id__.is_some() {
8428 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8429 }
8430 associated_source_id__ =
8431 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8432 ;
8433 }
8434 }
8435 }
8436 Ok(ListFinishMutation {
8437 associated_source_id: associated_source_id__.unwrap_or_default(),
8438 })
8439 }
8440 }
8441 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
8442 }
8443}
8444impl serde::Serialize for LoadFinishMutation {
8445 #[allow(deprecated)]
8446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8447 where
8448 S: serde::Serializer,
8449 {
8450 use serde::ser::SerializeStruct;
8451 let mut len = 0;
8452 if self.associated_source_id != 0 {
8453 len += 1;
8454 }
8455 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
8456 if self.associated_source_id != 0 {
8457 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8458 }
8459 struct_ser.end()
8460 }
8461}
8462impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
8463 #[allow(deprecated)]
8464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8465 where
8466 D: serde::Deserializer<'de>,
8467 {
8468 const FIELDS: &[&str] = &[
8469 "associated_source_id",
8470 "associatedSourceId",
8471 ];
8472
8473 #[allow(clippy::enum_variant_names)]
8474 enum GeneratedField {
8475 AssociatedSourceId,
8476 }
8477 impl<'de> serde::Deserialize<'de> for GeneratedField {
8478 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8479 where
8480 D: serde::Deserializer<'de>,
8481 {
8482 struct GeneratedVisitor;
8483
8484 impl serde::de::Visitor<'_> for GeneratedVisitor {
8485 type Value = GeneratedField;
8486
8487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8488 write!(formatter, "expected one of: {:?}", &FIELDS)
8489 }
8490
8491 #[allow(unused_variables)]
8492 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8493 where
8494 E: serde::de::Error,
8495 {
8496 match value {
8497 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8498 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8499 }
8500 }
8501 }
8502 deserializer.deserialize_identifier(GeneratedVisitor)
8503 }
8504 }
8505 struct GeneratedVisitor;
8506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8507 type Value = LoadFinishMutation;
8508
8509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8510 formatter.write_str("struct stream_plan.LoadFinishMutation")
8511 }
8512
8513 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
8514 where
8515 V: serde::de::MapAccess<'de>,
8516 {
8517 let mut associated_source_id__ = None;
8518 while let Some(k) = map_.next_key()? {
8519 match k {
8520 GeneratedField::AssociatedSourceId => {
8521 if associated_source_id__.is_some() {
8522 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8523 }
8524 associated_source_id__ =
8525 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8526 ;
8527 }
8528 }
8529 }
8530 Ok(LoadFinishMutation {
8531 associated_source_id: associated_source_id__.unwrap_or_default(),
8532 })
8533 }
8534 }
8535 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
8536 }
8537}
8538impl serde::Serialize for LocalApproxPercentileNode {
8539 #[allow(deprecated)]
8540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8541 where
8542 S: serde::Serializer,
8543 {
8544 use serde::ser::SerializeStruct;
8545 let mut len = 0;
8546 if self.base != 0. {
8547 len += 1;
8548 }
8549 if self.percentile_index != 0 {
8550 len += 1;
8551 }
8552 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
8553 if self.base != 0. {
8554 struct_ser.serialize_field("base", &self.base)?;
8555 }
8556 if self.percentile_index != 0 {
8557 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
8558 }
8559 struct_ser.end()
8560 }
8561}
8562impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
8563 #[allow(deprecated)]
8564 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8565 where
8566 D: serde::Deserializer<'de>,
8567 {
8568 const FIELDS: &[&str] = &[
8569 "base",
8570 "percentile_index",
8571 "percentileIndex",
8572 ];
8573
8574 #[allow(clippy::enum_variant_names)]
8575 enum GeneratedField {
8576 Base,
8577 PercentileIndex,
8578 }
8579 impl<'de> serde::Deserialize<'de> for GeneratedField {
8580 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8581 where
8582 D: serde::Deserializer<'de>,
8583 {
8584 struct GeneratedVisitor;
8585
8586 impl serde::de::Visitor<'_> for GeneratedVisitor {
8587 type Value = GeneratedField;
8588
8589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8590 write!(formatter, "expected one of: {:?}", &FIELDS)
8591 }
8592
8593 #[allow(unused_variables)]
8594 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8595 where
8596 E: serde::de::Error,
8597 {
8598 match value {
8599 "base" => Ok(GeneratedField::Base),
8600 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
8601 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8602 }
8603 }
8604 }
8605 deserializer.deserialize_identifier(GeneratedVisitor)
8606 }
8607 }
8608 struct GeneratedVisitor;
8609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8610 type Value = LocalApproxPercentileNode;
8611
8612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8613 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
8614 }
8615
8616 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
8617 where
8618 V: serde::de::MapAccess<'de>,
8619 {
8620 let mut base__ = None;
8621 let mut percentile_index__ = None;
8622 while let Some(k) = map_.next_key()? {
8623 match k {
8624 GeneratedField::Base => {
8625 if base__.is_some() {
8626 return Err(serde::de::Error::duplicate_field("base"));
8627 }
8628 base__ =
8629 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8630 ;
8631 }
8632 GeneratedField::PercentileIndex => {
8633 if percentile_index__.is_some() {
8634 return Err(serde::de::Error::duplicate_field("percentileIndex"));
8635 }
8636 percentile_index__ =
8637 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8638 ;
8639 }
8640 }
8641 }
8642 Ok(LocalApproxPercentileNode {
8643 base: base__.unwrap_or_default(),
8644 percentile_index: percentile_index__.unwrap_or_default(),
8645 })
8646 }
8647 }
8648 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
8649 }
8650}
8651impl serde::Serialize for LocalityProviderNode {
8652 #[allow(deprecated)]
8653 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8654 where
8655 S: serde::Serializer,
8656 {
8657 use serde::ser::SerializeStruct;
8658 let mut len = 0;
8659 if !self.locality_columns.is_empty() {
8660 len += 1;
8661 }
8662 if self.state_table.is_some() {
8663 len += 1;
8664 }
8665 if self.progress_table.is_some() {
8666 len += 1;
8667 }
8668 if self.rate_limit.is_some() {
8669 len += 1;
8670 }
8671 if self.sort_buffer_table.is_some() {
8672 len += 1;
8673 }
8674 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
8675 if !self.locality_columns.is_empty() {
8676 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
8677 }
8678 if let Some(v) = self.state_table.as_ref() {
8679 struct_ser.serialize_field("stateTable", v)?;
8680 }
8681 if let Some(v) = self.progress_table.as_ref() {
8682 struct_ser.serialize_field("progressTable", v)?;
8683 }
8684 if let Some(v) = self.rate_limit.as_ref() {
8685 struct_ser.serialize_field("rateLimit", v)?;
8686 }
8687 if let Some(v) = self.sort_buffer_table.as_ref() {
8688 struct_ser.serialize_field("sortBufferTable", v)?;
8689 }
8690 struct_ser.end()
8691 }
8692}
8693impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
8694 #[allow(deprecated)]
8695 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8696 where
8697 D: serde::Deserializer<'de>,
8698 {
8699 const FIELDS: &[&str] = &[
8700 "locality_columns",
8701 "localityColumns",
8702 "state_table",
8703 "stateTable",
8704 "progress_table",
8705 "progressTable",
8706 "rate_limit",
8707 "rateLimit",
8708 "sort_buffer_table",
8709 "sortBufferTable",
8710 ];
8711
8712 #[allow(clippy::enum_variant_names)]
8713 enum GeneratedField {
8714 LocalityColumns,
8715 StateTable,
8716 ProgressTable,
8717 RateLimit,
8718 SortBufferTable,
8719 }
8720 impl<'de> serde::Deserialize<'de> for GeneratedField {
8721 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8722 where
8723 D: serde::Deserializer<'de>,
8724 {
8725 struct GeneratedVisitor;
8726
8727 impl serde::de::Visitor<'_> for GeneratedVisitor {
8728 type Value = GeneratedField;
8729
8730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8731 write!(formatter, "expected one of: {:?}", &FIELDS)
8732 }
8733
8734 #[allow(unused_variables)]
8735 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8736 where
8737 E: serde::de::Error,
8738 {
8739 match value {
8740 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
8741 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8742 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
8743 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8744 "sortBufferTable" | "sort_buffer_table" => Ok(GeneratedField::SortBufferTable),
8745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8746 }
8747 }
8748 }
8749 deserializer.deserialize_identifier(GeneratedVisitor)
8750 }
8751 }
8752 struct GeneratedVisitor;
8753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8754 type Value = LocalityProviderNode;
8755
8756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8757 formatter.write_str("struct stream_plan.LocalityProviderNode")
8758 }
8759
8760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
8761 where
8762 V: serde::de::MapAccess<'de>,
8763 {
8764 let mut locality_columns__ = None;
8765 let mut state_table__ = None;
8766 let mut progress_table__ = None;
8767 let mut rate_limit__ = None;
8768 let mut sort_buffer_table__ = None;
8769 while let Some(k) = map_.next_key()? {
8770 match k {
8771 GeneratedField::LocalityColumns => {
8772 if locality_columns__.is_some() {
8773 return Err(serde::de::Error::duplicate_field("localityColumns"));
8774 }
8775 locality_columns__ =
8776 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8777 .into_iter().map(|x| x.0).collect())
8778 ;
8779 }
8780 GeneratedField::StateTable => {
8781 if state_table__.is_some() {
8782 return Err(serde::de::Error::duplicate_field("stateTable"));
8783 }
8784 state_table__ = map_.next_value()?;
8785 }
8786 GeneratedField::ProgressTable => {
8787 if progress_table__.is_some() {
8788 return Err(serde::de::Error::duplicate_field("progressTable"));
8789 }
8790 progress_table__ = map_.next_value()?;
8791 }
8792 GeneratedField::RateLimit => {
8793 if rate_limit__.is_some() {
8794 return Err(serde::de::Error::duplicate_field("rateLimit"));
8795 }
8796 rate_limit__ =
8797 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8798 ;
8799 }
8800 GeneratedField::SortBufferTable => {
8801 if sort_buffer_table__.is_some() {
8802 return Err(serde::de::Error::duplicate_field("sortBufferTable"));
8803 }
8804 sort_buffer_table__ = map_.next_value()?;
8805 }
8806 }
8807 }
8808 Ok(LocalityProviderNode {
8809 locality_columns: locality_columns__.unwrap_or_default(),
8810 state_table: state_table__,
8811 progress_table: progress_table__,
8812 rate_limit: rate_limit__,
8813 sort_buffer_table: sort_buffer_table__,
8814 })
8815 }
8816 }
8817 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
8818 }
8819}
8820impl serde::Serialize for LookupNode {
8821 #[allow(deprecated)]
8822 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8823 where
8824 S: serde::Serializer,
8825 {
8826 use serde::ser::SerializeStruct;
8827 let mut len = 0;
8828 if !self.arrange_key.is_empty() {
8829 len += 1;
8830 }
8831 if !self.stream_key.is_empty() {
8832 len += 1;
8833 }
8834 if self.use_current_epoch {
8835 len += 1;
8836 }
8837 if !self.column_mapping.is_empty() {
8838 len += 1;
8839 }
8840 if self.arrangement_table_info.is_some() {
8841 len += 1;
8842 }
8843 if self.arrangement_table_id.is_some() {
8844 len += 1;
8845 }
8846 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
8847 if !self.arrange_key.is_empty() {
8848 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
8849 }
8850 if !self.stream_key.is_empty() {
8851 struct_ser.serialize_field("streamKey", &self.stream_key)?;
8852 }
8853 if self.use_current_epoch {
8854 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
8855 }
8856 if !self.column_mapping.is_empty() {
8857 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
8858 }
8859 if let Some(v) = self.arrangement_table_info.as_ref() {
8860 struct_ser.serialize_field("arrangementTableInfo", v)?;
8861 }
8862 if let Some(v) = self.arrangement_table_id.as_ref() {
8863 match v {
8864 lookup_node::ArrangementTableId::TableId(v) => {
8865 struct_ser.serialize_field("tableId", v)?;
8866 }
8867 lookup_node::ArrangementTableId::IndexId(v) => {
8868 struct_ser.serialize_field("indexId", v)?;
8869 }
8870 }
8871 }
8872 struct_ser.end()
8873 }
8874}
8875impl<'de> serde::Deserialize<'de> for LookupNode {
8876 #[allow(deprecated)]
8877 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8878 where
8879 D: serde::Deserializer<'de>,
8880 {
8881 const FIELDS: &[&str] = &[
8882 "arrange_key",
8883 "arrangeKey",
8884 "stream_key",
8885 "streamKey",
8886 "use_current_epoch",
8887 "useCurrentEpoch",
8888 "column_mapping",
8889 "columnMapping",
8890 "arrangement_table_info",
8891 "arrangementTableInfo",
8892 "table_id",
8893 "tableId",
8894 "index_id",
8895 "indexId",
8896 ];
8897
8898 #[allow(clippy::enum_variant_names)]
8899 enum GeneratedField {
8900 ArrangeKey,
8901 StreamKey,
8902 UseCurrentEpoch,
8903 ColumnMapping,
8904 ArrangementTableInfo,
8905 TableId,
8906 IndexId,
8907 }
8908 impl<'de> serde::Deserialize<'de> for GeneratedField {
8909 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8910 where
8911 D: serde::Deserializer<'de>,
8912 {
8913 struct GeneratedVisitor;
8914
8915 impl serde::de::Visitor<'_> for GeneratedVisitor {
8916 type Value = GeneratedField;
8917
8918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8919 write!(formatter, "expected one of: {:?}", &FIELDS)
8920 }
8921
8922 #[allow(unused_variables)]
8923 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8924 where
8925 E: serde::de::Error,
8926 {
8927 match value {
8928 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
8929 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
8930 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
8931 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
8932 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
8933 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8934 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8935 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8936 }
8937 }
8938 }
8939 deserializer.deserialize_identifier(GeneratedVisitor)
8940 }
8941 }
8942 struct GeneratedVisitor;
8943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8944 type Value = LookupNode;
8945
8946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8947 formatter.write_str("struct stream_plan.LookupNode")
8948 }
8949
8950 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
8951 where
8952 V: serde::de::MapAccess<'de>,
8953 {
8954 let mut arrange_key__ = None;
8955 let mut stream_key__ = None;
8956 let mut use_current_epoch__ = None;
8957 let mut column_mapping__ = None;
8958 let mut arrangement_table_info__ = None;
8959 let mut arrangement_table_id__ = None;
8960 while let Some(k) = map_.next_key()? {
8961 match k {
8962 GeneratedField::ArrangeKey => {
8963 if arrange_key__.is_some() {
8964 return Err(serde::de::Error::duplicate_field("arrangeKey"));
8965 }
8966 arrange_key__ =
8967 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8968 .into_iter().map(|x| x.0).collect())
8969 ;
8970 }
8971 GeneratedField::StreamKey => {
8972 if stream_key__.is_some() {
8973 return Err(serde::de::Error::duplicate_field("streamKey"));
8974 }
8975 stream_key__ =
8976 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8977 .into_iter().map(|x| x.0).collect())
8978 ;
8979 }
8980 GeneratedField::UseCurrentEpoch => {
8981 if use_current_epoch__.is_some() {
8982 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
8983 }
8984 use_current_epoch__ = Some(map_.next_value()?);
8985 }
8986 GeneratedField::ColumnMapping => {
8987 if column_mapping__.is_some() {
8988 return Err(serde::de::Error::duplicate_field("columnMapping"));
8989 }
8990 column_mapping__ =
8991 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8992 .into_iter().map(|x| x.0).collect())
8993 ;
8994 }
8995 GeneratedField::ArrangementTableInfo => {
8996 if arrangement_table_info__.is_some() {
8997 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
8998 }
8999 arrangement_table_info__ = map_.next_value()?;
9000 }
9001 GeneratedField::TableId => {
9002 if arrangement_table_id__.is_some() {
9003 return Err(serde::de::Error::duplicate_field("tableId"));
9004 }
9005 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
9006 }
9007 GeneratedField::IndexId => {
9008 if arrangement_table_id__.is_some() {
9009 return Err(serde::de::Error::duplicate_field("indexId"));
9010 }
9011 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
9012 }
9013 }
9014 }
9015 Ok(LookupNode {
9016 arrange_key: arrange_key__.unwrap_or_default(),
9017 stream_key: stream_key__.unwrap_or_default(),
9018 use_current_epoch: use_current_epoch__.unwrap_or_default(),
9019 column_mapping: column_mapping__.unwrap_or_default(),
9020 arrangement_table_info: arrangement_table_info__,
9021 arrangement_table_id: arrangement_table_id__,
9022 })
9023 }
9024 }
9025 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
9026 }
9027}
9028impl serde::Serialize for LookupUnionNode {
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.order.is_empty() {
9037 len += 1;
9038 }
9039 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
9040 if !self.order.is_empty() {
9041 struct_ser.serialize_field("order", &self.order)?;
9042 }
9043 struct_ser.end()
9044 }
9045}
9046impl<'de> serde::Deserialize<'de> for LookupUnionNode {
9047 #[allow(deprecated)]
9048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9049 where
9050 D: serde::Deserializer<'de>,
9051 {
9052 const FIELDS: &[&str] = &[
9053 "order",
9054 ];
9055
9056 #[allow(clippy::enum_variant_names)]
9057 enum GeneratedField {
9058 Order,
9059 }
9060 impl<'de> serde::Deserialize<'de> for GeneratedField {
9061 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9062 where
9063 D: serde::Deserializer<'de>,
9064 {
9065 struct GeneratedVisitor;
9066
9067 impl serde::de::Visitor<'_> for GeneratedVisitor {
9068 type Value = GeneratedField;
9069
9070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9071 write!(formatter, "expected one of: {:?}", &FIELDS)
9072 }
9073
9074 #[allow(unused_variables)]
9075 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9076 where
9077 E: serde::de::Error,
9078 {
9079 match value {
9080 "order" => Ok(GeneratedField::Order),
9081 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9082 }
9083 }
9084 }
9085 deserializer.deserialize_identifier(GeneratedVisitor)
9086 }
9087 }
9088 struct GeneratedVisitor;
9089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9090 type Value = LookupUnionNode;
9091
9092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9093 formatter.write_str("struct stream_plan.LookupUnionNode")
9094 }
9095
9096 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
9097 where
9098 V: serde::de::MapAccess<'de>,
9099 {
9100 let mut order__ = None;
9101 while let Some(k) = map_.next_key()? {
9102 match k {
9103 GeneratedField::Order => {
9104 if order__.is_some() {
9105 return Err(serde::de::Error::duplicate_field("order"));
9106 }
9107 order__ =
9108 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9109 .into_iter().map(|x| x.0).collect())
9110 ;
9111 }
9112 }
9113 }
9114 Ok(LookupUnionNode {
9115 order: order__.unwrap_or_default(),
9116 })
9117 }
9118 }
9119 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
9120 }
9121}
9122impl serde::Serialize for MatchRecognizeAfterMatchSkip {
9123 #[allow(deprecated)]
9124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9125 where
9126 S: serde::Serializer,
9127 {
9128 use serde::ser::SerializeStruct;
9129 let mut len = 0;
9130 if self.mode != 0 {
9131 len += 1;
9132 }
9133 if self.target.is_some() {
9134 len += 1;
9135 }
9136 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeAfterMatchSkip", len)?;
9137 if self.mode != 0 {
9138 let v = match_recognize_after_match_skip::Mode::try_from(self.mode)
9139 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?;
9140 struct_ser.serialize_field("mode", &v)?;
9141 }
9142 if let Some(v) = self.target.as_ref() {
9143 struct_ser.serialize_field("target", v)?;
9144 }
9145 struct_ser.end()
9146 }
9147}
9148impl<'de> serde::Deserialize<'de> for MatchRecognizeAfterMatchSkip {
9149 #[allow(deprecated)]
9150 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9151 where
9152 D: serde::Deserializer<'de>,
9153 {
9154 const FIELDS: &[&str] = &[
9155 "mode",
9156 "target",
9157 ];
9158
9159 #[allow(clippy::enum_variant_names)]
9160 enum GeneratedField {
9161 Mode,
9162 Target,
9163 }
9164 impl<'de> serde::Deserialize<'de> for GeneratedField {
9165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9166 where
9167 D: serde::Deserializer<'de>,
9168 {
9169 struct GeneratedVisitor;
9170
9171 impl serde::de::Visitor<'_> for GeneratedVisitor {
9172 type Value = GeneratedField;
9173
9174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9175 write!(formatter, "expected one of: {:?}", &FIELDS)
9176 }
9177
9178 #[allow(unused_variables)]
9179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9180 where
9181 E: serde::de::Error,
9182 {
9183 match value {
9184 "mode" => Ok(GeneratedField::Mode),
9185 "target" => Ok(GeneratedField::Target),
9186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9187 }
9188 }
9189 }
9190 deserializer.deserialize_identifier(GeneratedVisitor)
9191 }
9192 }
9193 struct GeneratedVisitor;
9194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9195 type Value = MatchRecognizeAfterMatchSkip;
9196
9197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9198 formatter.write_str("struct stream_plan.MatchRecognizeAfterMatchSkip")
9199 }
9200
9201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeAfterMatchSkip, V::Error>
9202 where
9203 V: serde::de::MapAccess<'de>,
9204 {
9205 let mut mode__ = None;
9206 let mut target__ = None;
9207 while let Some(k) = map_.next_key()? {
9208 match k {
9209 GeneratedField::Mode => {
9210 if mode__.is_some() {
9211 return Err(serde::de::Error::duplicate_field("mode"));
9212 }
9213 mode__ = Some(map_.next_value::<match_recognize_after_match_skip::Mode>()? as i32);
9214 }
9215 GeneratedField::Target => {
9216 if target__.is_some() {
9217 return Err(serde::de::Error::duplicate_field("target"));
9218 }
9219 target__ = map_.next_value()?;
9220 }
9221 }
9222 }
9223 Ok(MatchRecognizeAfterMatchSkip {
9224 mode: mode__.unwrap_or_default(),
9225 target: target__,
9226 })
9227 }
9228 }
9229 deserializer.deserialize_struct("stream_plan.MatchRecognizeAfterMatchSkip", FIELDS, GeneratedVisitor)
9230 }
9231}
9232impl serde::Serialize for match_recognize_after_match_skip::Mode {
9233 #[allow(deprecated)]
9234 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9235 where
9236 S: serde::Serializer,
9237 {
9238 let variant = match self {
9239 Self::Unspecified => "MODE_UNSPECIFIED",
9240 Self::PastLastRow => "MODE_PAST_LAST_ROW",
9241 Self::ToNextRow => "MODE_TO_NEXT_ROW",
9242 Self::ToFirst => "MODE_TO_FIRST",
9243 Self::ToLast => "MODE_TO_LAST",
9244 };
9245 serializer.serialize_str(variant)
9246 }
9247}
9248impl<'de> serde::Deserialize<'de> for match_recognize_after_match_skip::Mode {
9249 #[allow(deprecated)]
9250 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9251 where
9252 D: serde::Deserializer<'de>,
9253 {
9254 const FIELDS: &[&str] = &[
9255 "MODE_UNSPECIFIED",
9256 "MODE_PAST_LAST_ROW",
9257 "MODE_TO_NEXT_ROW",
9258 "MODE_TO_FIRST",
9259 "MODE_TO_LAST",
9260 ];
9261
9262 struct GeneratedVisitor;
9263
9264 impl serde::de::Visitor<'_> for GeneratedVisitor {
9265 type Value = match_recognize_after_match_skip::Mode;
9266
9267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9268 write!(formatter, "expected one of: {:?}", &FIELDS)
9269 }
9270
9271 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9272 where
9273 E: serde::de::Error,
9274 {
9275 i32::try_from(v)
9276 .ok()
9277 .and_then(|x| x.try_into().ok())
9278 .ok_or_else(|| {
9279 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9280 })
9281 }
9282
9283 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9284 where
9285 E: serde::de::Error,
9286 {
9287 i32::try_from(v)
9288 .ok()
9289 .and_then(|x| x.try_into().ok())
9290 .ok_or_else(|| {
9291 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9292 })
9293 }
9294
9295 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9296 where
9297 E: serde::de::Error,
9298 {
9299 match value {
9300 "MODE_UNSPECIFIED" => Ok(match_recognize_after_match_skip::Mode::Unspecified),
9301 "MODE_PAST_LAST_ROW" => Ok(match_recognize_after_match_skip::Mode::PastLastRow),
9302 "MODE_TO_NEXT_ROW" => Ok(match_recognize_after_match_skip::Mode::ToNextRow),
9303 "MODE_TO_FIRST" => Ok(match_recognize_after_match_skip::Mode::ToFirst),
9304 "MODE_TO_LAST" => Ok(match_recognize_after_match_skip::Mode::ToLast),
9305 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9306 }
9307 }
9308 }
9309 deserializer.deserialize_any(GeneratedVisitor)
9310 }
9311}
9312impl serde::Serialize for MatchRecognizeDefine {
9313 #[allow(deprecated)]
9314 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9315 where
9316 S: serde::Serializer,
9317 {
9318 use serde::ser::SerializeStruct;
9319 let mut len = 0;
9320 if !self.symbol.is_empty() {
9321 len += 1;
9322 }
9323 if self.condition.is_some() {
9324 len += 1;
9325 }
9326 if !self.slots.is_empty() {
9327 len += 1;
9328 }
9329 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeDefine", len)?;
9330 if !self.symbol.is_empty() {
9331 struct_ser.serialize_field("symbol", &self.symbol)?;
9332 }
9333 if let Some(v) = self.condition.as_ref() {
9334 struct_ser.serialize_field("condition", v)?;
9335 }
9336 if !self.slots.is_empty() {
9337 struct_ser.serialize_field("slots", &self.slots)?;
9338 }
9339 struct_ser.end()
9340 }
9341}
9342impl<'de> serde::Deserialize<'de> for MatchRecognizeDefine {
9343 #[allow(deprecated)]
9344 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9345 where
9346 D: serde::Deserializer<'de>,
9347 {
9348 const FIELDS: &[&str] = &[
9349 "symbol",
9350 "condition",
9351 "slots",
9352 ];
9353
9354 #[allow(clippy::enum_variant_names)]
9355 enum GeneratedField {
9356 Symbol,
9357 Condition,
9358 Slots,
9359 }
9360 impl<'de> serde::Deserialize<'de> for GeneratedField {
9361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9362 where
9363 D: serde::Deserializer<'de>,
9364 {
9365 struct GeneratedVisitor;
9366
9367 impl serde::de::Visitor<'_> for GeneratedVisitor {
9368 type Value = GeneratedField;
9369
9370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9371 write!(formatter, "expected one of: {:?}", &FIELDS)
9372 }
9373
9374 #[allow(unused_variables)]
9375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9376 where
9377 E: serde::de::Error,
9378 {
9379 match value {
9380 "symbol" => Ok(GeneratedField::Symbol),
9381 "condition" => Ok(GeneratedField::Condition),
9382 "slots" => Ok(GeneratedField::Slots),
9383 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9384 }
9385 }
9386 }
9387 deserializer.deserialize_identifier(GeneratedVisitor)
9388 }
9389 }
9390 struct GeneratedVisitor;
9391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9392 type Value = MatchRecognizeDefine;
9393
9394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9395 formatter.write_str("struct stream_plan.MatchRecognizeDefine")
9396 }
9397
9398 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeDefine, V::Error>
9399 where
9400 V: serde::de::MapAccess<'de>,
9401 {
9402 let mut symbol__ = None;
9403 let mut condition__ = None;
9404 let mut slots__ = None;
9405 while let Some(k) = map_.next_key()? {
9406 match k {
9407 GeneratedField::Symbol => {
9408 if symbol__.is_some() {
9409 return Err(serde::de::Error::duplicate_field("symbol"));
9410 }
9411 symbol__ = Some(map_.next_value()?);
9412 }
9413 GeneratedField::Condition => {
9414 if condition__.is_some() {
9415 return Err(serde::de::Error::duplicate_field("condition"));
9416 }
9417 condition__ = map_.next_value()?;
9418 }
9419 GeneratedField::Slots => {
9420 if slots__.is_some() {
9421 return Err(serde::de::Error::duplicate_field("slots"));
9422 }
9423 slots__ = Some(map_.next_value()?);
9424 }
9425 }
9426 }
9427 Ok(MatchRecognizeDefine {
9428 symbol: symbol__.unwrap_or_default(),
9429 condition: condition__,
9430 slots: slots__.unwrap_or_default(),
9431 })
9432 }
9433 }
9434 deserializer.deserialize_struct("stream_plan.MatchRecognizeDefine", FIELDS, GeneratedVisitor)
9435 }
9436}
9437impl serde::Serialize for MatchRecognizeDefineSlot {
9438 #[allow(deprecated)]
9439 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9440 where
9441 S: serde::Serializer,
9442 {
9443 use serde::ser::SerializeStruct;
9444 let mut len = 0;
9445 if self.kind != 0 {
9446 len += 1;
9447 }
9448 if !self.vars.is_empty() {
9449 len += 1;
9450 }
9451 if self.col_idx != 0 {
9452 len += 1;
9453 }
9454 if self.offset != 0 {
9455 len += 1;
9456 }
9457 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeDefineSlot", len)?;
9458 if self.kind != 0 {
9459 let v = match_recognize_define_slot::Kind::try_from(self.kind)
9460 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
9461 struct_ser.serialize_field("kind", &v)?;
9462 }
9463 if !self.vars.is_empty() {
9464 struct_ser.serialize_field("vars", &self.vars)?;
9465 }
9466 if self.col_idx != 0 {
9467 struct_ser.serialize_field("colIdx", &self.col_idx)?;
9468 }
9469 if self.offset != 0 {
9470 struct_ser.serialize_field("offset", &self.offset)?;
9471 }
9472 struct_ser.end()
9473 }
9474}
9475impl<'de> serde::Deserialize<'de> for MatchRecognizeDefineSlot {
9476 #[allow(deprecated)]
9477 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9478 where
9479 D: serde::Deserializer<'de>,
9480 {
9481 const FIELDS: &[&str] = &[
9482 "kind",
9483 "vars",
9484 "col_idx",
9485 "colIdx",
9486 "offset",
9487 ];
9488
9489 #[allow(clippy::enum_variant_names)]
9490 enum GeneratedField {
9491 Kind,
9492 Vars,
9493 ColIdx,
9494 Offset,
9495 }
9496 impl<'de> serde::Deserialize<'de> for GeneratedField {
9497 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9498 where
9499 D: serde::Deserializer<'de>,
9500 {
9501 struct GeneratedVisitor;
9502
9503 impl serde::de::Visitor<'_> for GeneratedVisitor {
9504 type Value = GeneratedField;
9505
9506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9507 write!(formatter, "expected one of: {:?}", &FIELDS)
9508 }
9509
9510 #[allow(unused_variables)]
9511 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9512 where
9513 E: serde::de::Error,
9514 {
9515 match value {
9516 "kind" => Ok(GeneratedField::Kind),
9517 "vars" => Ok(GeneratedField::Vars),
9518 "colIdx" | "col_idx" => Ok(GeneratedField::ColIdx),
9519 "offset" => Ok(GeneratedField::Offset),
9520 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9521 }
9522 }
9523 }
9524 deserializer.deserialize_identifier(GeneratedVisitor)
9525 }
9526 }
9527 struct GeneratedVisitor;
9528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9529 type Value = MatchRecognizeDefineSlot;
9530
9531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9532 formatter.write_str("struct stream_plan.MatchRecognizeDefineSlot")
9533 }
9534
9535 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeDefineSlot, V::Error>
9536 where
9537 V: serde::de::MapAccess<'de>,
9538 {
9539 let mut kind__ = None;
9540 let mut vars__ = None;
9541 let mut col_idx__ = None;
9542 let mut offset__ = None;
9543 while let Some(k) = map_.next_key()? {
9544 match k {
9545 GeneratedField::Kind => {
9546 if kind__.is_some() {
9547 return Err(serde::de::Error::duplicate_field("kind"));
9548 }
9549 kind__ = Some(map_.next_value::<match_recognize_define_slot::Kind>()? as i32);
9550 }
9551 GeneratedField::Vars => {
9552 if vars__.is_some() {
9553 return Err(serde::de::Error::duplicate_field("vars"));
9554 }
9555 vars__ = Some(map_.next_value()?);
9556 }
9557 GeneratedField::ColIdx => {
9558 if col_idx__.is_some() {
9559 return Err(serde::de::Error::duplicate_field("colIdx"));
9560 }
9561 col_idx__ =
9562 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9563 ;
9564 }
9565 GeneratedField::Offset => {
9566 if offset__.is_some() {
9567 return Err(serde::de::Error::duplicate_field("offset"));
9568 }
9569 offset__ =
9570 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9571 ;
9572 }
9573 }
9574 }
9575 Ok(MatchRecognizeDefineSlot {
9576 kind: kind__.unwrap_or_default(),
9577 vars: vars__.unwrap_or_default(),
9578 col_idx: col_idx__.unwrap_or_default(),
9579 offset: offset__.unwrap_or_default(),
9580 })
9581 }
9582 }
9583 deserializer.deserialize_struct("stream_plan.MatchRecognizeDefineSlot", FIELDS, GeneratedVisitor)
9584 }
9585}
9586impl serde::Serialize for match_recognize_define_slot::Kind {
9587 #[allow(deprecated)]
9588 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9589 where
9590 S: serde::Serializer,
9591 {
9592 let variant = match self {
9593 Self::Unspecified => "KIND_UNSPECIFIED",
9594 Self::SelfCol => "KIND_SELF_COL",
9595 Self::Prev => "KIND_PREV",
9596 Self::Next => "KIND_NEXT",
9597 Self::RunningFirst => "KIND_RUNNING_FIRST",
9598 Self::RunningLast => "KIND_RUNNING_LAST",
9599 };
9600 serializer.serialize_str(variant)
9601 }
9602}
9603impl<'de> serde::Deserialize<'de> for match_recognize_define_slot::Kind {
9604 #[allow(deprecated)]
9605 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9606 where
9607 D: serde::Deserializer<'de>,
9608 {
9609 const FIELDS: &[&str] = &[
9610 "KIND_UNSPECIFIED",
9611 "KIND_SELF_COL",
9612 "KIND_PREV",
9613 "KIND_NEXT",
9614 "KIND_RUNNING_FIRST",
9615 "KIND_RUNNING_LAST",
9616 ];
9617
9618 struct GeneratedVisitor;
9619
9620 impl serde::de::Visitor<'_> for GeneratedVisitor {
9621 type Value = match_recognize_define_slot::Kind;
9622
9623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9624 write!(formatter, "expected one of: {:?}", &FIELDS)
9625 }
9626
9627 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9628 where
9629 E: serde::de::Error,
9630 {
9631 i32::try_from(v)
9632 .ok()
9633 .and_then(|x| x.try_into().ok())
9634 .ok_or_else(|| {
9635 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9636 })
9637 }
9638
9639 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9640 where
9641 E: serde::de::Error,
9642 {
9643 i32::try_from(v)
9644 .ok()
9645 .and_then(|x| x.try_into().ok())
9646 .ok_or_else(|| {
9647 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9648 })
9649 }
9650
9651 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9652 where
9653 E: serde::de::Error,
9654 {
9655 match value {
9656 "KIND_UNSPECIFIED" => Ok(match_recognize_define_slot::Kind::Unspecified),
9657 "KIND_SELF_COL" => Ok(match_recognize_define_slot::Kind::SelfCol),
9658 "KIND_PREV" => Ok(match_recognize_define_slot::Kind::Prev),
9659 "KIND_NEXT" => Ok(match_recognize_define_slot::Kind::Next),
9660 "KIND_RUNNING_FIRST" => Ok(match_recognize_define_slot::Kind::RunningFirst),
9661 "KIND_RUNNING_LAST" => Ok(match_recognize_define_slot::Kind::RunningLast),
9662 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9663 }
9664 }
9665 }
9666 deserializer.deserialize_any(GeneratedVisitor)
9667 }
9668}
9669impl serde::Serialize for MatchRecognizeInputMode {
9670 #[allow(deprecated)]
9671 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9672 where
9673 S: serde::Serializer,
9674 {
9675 let variant = match self {
9676 Self::Unspecified => "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED",
9677 Self::EventTime => "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME",
9678 Self::ProcessingTime => "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME",
9679 };
9680 serializer.serialize_str(variant)
9681 }
9682}
9683impl<'de> serde::Deserialize<'de> for MatchRecognizeInputMode {
9684 #[allow(deprecated)]
9685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9686 where
9687 D: serde::Deserializer<'de>,
9688 {
9689 const FIELDS: &[&str] = &[
9690 "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED",
9691 "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME",
9692 "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME",
9693 ];
9694
9695 struct GeneratedVisitor;
9696
9697 impl serde::de::Visitor<'_> for GeneratedVisitor {
9698 type Value = MatchRecognizeInputMode;
9699
9700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9701 write!(formatter, "expected one of: {:?}", &FIELDS)
9702 }
9703
9704 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9705 where
9706 E: serde::de::Error,
9707 {
9708 i32::try_from(v)
9709 .ok()
9710 .and_then(|x| x.try_into().ok())
9711 .ok_or_else(|| {
9712 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9713 })
9714 }
9715
9716 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9717 where
9718 E: serde::de::Error,
9719 {
9720 i32::try_from(v)
9721 .ok()
9722 .and_then(|x| x.try_into().ok())
9723 .ok_or_else(|| {
9724 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9725 })
9726 }
9727
9728 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9729 where
9730 E: serde::de::Error,
9731 {
9732 match value {
9733 "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED" => Ok(MatchRecognizeInputMode::Unspecified),
9734 "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME" => Ok(MatchRecognizeInputMode::EventTime),
9735 "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME" => Ok(MatchRecognizeInputMode::ProcessingTime),
9736 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9737 }
9738 }
9739 }
9740 deserializer.deserialize_any(GeneratedVisitor)
9741 }
9742}
9743impl serde::Serialize for MatchRecognizeMeasure {
9744 #[allow(deprecated)]
9745 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9746 where
9747 S: serde::Serializer,
9748 {
9749 use serde::ser::SerializeStruct;
9750 let mut len = 0;
9751 if self.expr.is_some() {
9752 len += 1;
9753 }
9754 if !self.name.is_empty() {
9755 len += 1;
9756 }
9757 if !self.slots.is_empty() {
9758 len += 1;
9759 }
9760 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeMeasure", len)?;
9761 if let Some(v) = self.expr.as_ref() {
9762 struct_ser.serialize_field("expr", v)?;
9763 }
9764 if !self.name.is_empty() {
9765 struct_ser.serialize_field("name", &self.name)?;
9766 }
9767 if !self.slots.is_empty() {
9768 struct_ser.serialize_field("slots", &self.slots)?;
9769 }
9770 struct_ser.end()
9771 }
9772}
9773impl<'de> serde::Deserialize<'de> for MatchRecognizeMeasure {
9774 #[allow(deprecated)]
9775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9776 where
9777 D: serde::Deserializer<'de>,
9778 {
9779 const FIELDS: &[&str] = &[
9780 "expr",
9781 "name",
9782 "slots",
9783 ];
9784
9785 #[allow(clippy::enum_variant_names)]
9786 enum GeneratedField {
9787 Expr,
9788 Name,
9789 Slots,
9790 }
9791 impl<'de> serde::Deserialize<'de> for GeneratedField {
9792 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9793 where
9794 D: serde::Deserializer<'de>,
9795 {
9796 struct GeneratedVisitor;
9797
9798 impl serde::de::Visitor<'_> for GeneratedVisitor {
9799 type Value = GeneratedField;
9800
9801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9802 write!(formatter, "expected one of: {:?}", &FIELDS)
9803 }
9804
9805 #[allow(unused_variables)]
9806 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9807 where
9808 E: serde::de::Error,
9809 {
9810 match value {
9811 "expr" => Ok(GeneratedField::Expr),
9812 "name" => Ok(GeneratedField::Name),
9813 "slots" => Ok(GeneratedField::Slots),
9814 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9815 }
9816 }
9817 }
9818 deserializer.deserialize_identifier(GeneratedVisitor)
9819 }
9820 }
9821 struct GeneratedVisitor;
9822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9823 type Value = MatchRecognizeMeasure;
9824
9825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9826 formatter.write_str("struct stream_plan.MatchRecognizeMeasure")
9827 }
9828
9829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeMeasure, V::Error>
9830 where
9831 V: serde::de::MapAccess<'de>,
9832 {
9833 let mut expr__ = None;
9834 let mut name__ = None;
9835 let mut slots__ = None;
9836 while let Some(k) = map_.next_key()? {
9837 match k {
9838 GeneratedField::Expr => {
9839 if expr__.is_some() {
9840 return Err(serde::de::Error::duplicate_field("expr"));
9841 }
9842 expr__ = map_.next_value()?;
9843 }
9844 GeneratedField::Name => {
9845 if name__.is_some() {
9846 return Err(serde::de::Error::duplicate_field("name"));
9847 }
9848 name__ = Some(map_.next_value()?);
9849 }
9850 GeneratedField::Slots => {
9851 if slots__.is_some() {
9852 return Err(serde::de::Error::duplicate_field("slots"));
9853 }
9854 slots__ = Some(map_.next_value()?);
9855 }
9856 }
9857 }
9858 Ok(MatchRecognizeMeasure {
9859 expr: expr__,
9860 name: name__.unwrap_or_default(),
9861 slots: slots__.unwrap_or_default(),
9862 })
9863 }
9864 }
9865 deserializer.deserialize_struct("stream_plan.MatchRecognizeMeasure", FIELDS, GeneratedVisitor)
9866 }
9867}
9868impl serde::Serialize for MatchRecognizeMeasureSlot {
9869 #[allow(deprecated)]
9870 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9871 where
9872 S: serde::Serializer,
9873 {
9874 use serde::ser::SerializeStruct;
9875 let mut len = 0;
9876 if self.kind != 0 {
9877 len += 1;
9878 }
9879 if !self.vars.is_empty() {
9880 len += 1;
9881 }
9882 if self.col_idx != 0 {
9883 len += 1;
9884 }
9885 if self.data_type.is_some() {
9886 len += 1;
9887 }
9888 if self.agg_call.is_some() {
9889 len += 1;
9890 }
9891 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeMeasureSlot", len)?;
9892 if self.kind != 0 {
9893 let v = match_recognize_measure_slot::Kind::try_from(self.kind)
9894 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
9895 struct_ser.serialize_field("kind", &v)?;
9896 }
9897 if !self.vars.is_empty() {
9898 struct_ser.serialize_field("vars", &self.vars)?;
9899 }
9900 if self.col_idx != 0 {
9901 struct_ser.serialize_field("colIdx", &self.col_idx)?;
9902 }
9903 if let Some(v) = self.data_type.as_ref() {
9904 struct_ser.serialize_field("dataType", v)?;
9905 }
9906 if let Some(v) = self.agg_call.as_ref() {
9907 struct_ser.serialize_field("aggCall", v)?;
9908 }
9909 struct_ser.end()
9910 }
9911}
9912impl<'de> serde::Deserialize<'de> for MatchRecognizeMeasureSlot {
9913 #[allow(deprecated)]
9914 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9915 where
9916 D: serde::Deserializer<'de>,
9917 {
9918 const FIELDS: &[&str] = &[
9919 "kind",
9920 "vars",
9921 "col_idx",
9922 "colIdx",
9923 "data_type",
9924 "dataType",
9925 "agg_call",
9926 "aggCall",
9927 ];
9928
9929 #[allow(clippy::enum_variant_names)]
9930 enum GeneratedField {
9931 Kind,
9932 Vars,
9933 ColIdx,
9934 DataType,
9935 AggCall,
9936 }
9937 impl<'de> serde::Deserialize<'de> for GeneratedField {
9938 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9939 where
9940 D: serde::Deserializer<'de>,
9941 {
9942 struct GeneratedVisitor;
9943
9944 impl serde::de::Visitor<'_> for GeneratedVisitor {
9945 type Value = GeneratedField;
9946
9947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9948 write!(formatter, "expected one of: {:?}", &FIELDS)
9949 }
9950
9951 #[allow(unused_variables)]
9952 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9953 where
9954 E: serde::de::Error,
9955 {
9956 match value {
9957 "kind" => Ok(GeneratedField::Kind),
9958 "vars" => Ok(GeneratedField::Vars),
9959 "colIdx" | "col_idx" => Ok(GeneratedField::ColIdx),
9960 "dataType" | "data_type" => Ok(GeneratedField::DataType),
9961 "aggCall" | "agg_call" => Ok(GeneratedField::AggCall),
9962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9963 }
9964 }
9965 }
9966 deserializer.deserialize_identifier(GeneratedVisitor)
9967 }
9968 }
9969 struct GeneratedVisitor;
9970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9971 type Value = MatchRecognizeMeasureSlot;
9972
9973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9974 formatter.write_str("struct stream_plan.MatchRecognizeMeasureSlot")
9975 }
9976
9977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeMeasureSlot, V::Error>
9978 where
9979 V: serde::de::MapAccess<'de>,
9980 {
9981 let mut kind__ = None;
9982 let mut vars__ = None;
9983 let mut col_idx__ = None;
9984 let mut data_type__ = None;
9985 let mut agg_call__ = None;
9986 while let Some(k) = map_.next_key()? {
9987 match k {
9988 GeneratedField::Kind => {
9989 if kind__.is_some() {
9990 return Err(serde::de::Error::duplicate_field("kind"));
9991 }
9992 kind__ = Some(map_.next_value::<match_recognize_measure_slot::Kind>()? as i32);
9993 }
9994 GeneratedField::Vars => {
9995 if vars__.is_some() {
9996 return Err(serde::de::Error::duplicate_field("vars"));
9997 }
9998 vars__ = Some(map_.next_value()?);
9999 }
10000 GeneratedField::ColIdx => {
10001 if col_idx__.is_some() {
10002 return Err(serde::de::Error::duplicate_field("colIdx"));
10003 }
10004 col_idx__ =
10005 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10006 ;
10007 }
10008 GeneratedField::DataType => {
10009 if data_type__.is_some() {
10010 return Err(serde::de::Error::duplicate_field("dataType"));
10011 }
10012 data_type__ = map_.next_value()?;
10013 }
10014 GeneratedField::AggCall => {
10015 if agg_call__.is_some() {
10016 return Err(serde::de::Error::duplicate_field("aggCall"));
10017 }
10018 agg_call__ = map_.next_value()?;
10019 }
10020 }
10021 }
10022 Ok(MatchRecognizeMeasureSlot {
10023 kind: kind__.unwrap_or_default(),
10024 vars: vars__.unwrap_or_default(),
10025 col_idx: col_idx__.unwrap_or_default(),
10026 data_type: data_type__,
10027 agg_call: agg_call__,
10028 })
10029 }
10030 }
10031 deserializer.deserialize_struct("stream_plan.MatchRecognizeMeasureSlot", FIELDS, GeneratedVisitor)
10032 }
10033}
10034impl serde::Serialize for match_recognize_measure_slot::Kind {
10035 #[allow(deprecated)]
10036 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10037 where
10038 S: serde::Serializer,
10039 {
10040 let variant = match self {
10041 Self::Unspecified => "KIND_UNSPECIFIED",
10042 Self::Last => "KIND_LAST",
10043 Self::First => "KIND_FIRST",
10044 Self::Classifier => "KIND_CLASSIFIER",
10045 Self::CountStar => "KIND_COUNT_STAR",
10046 Self::Count => "KIND_COUNT",
10047 Self::Min => "KIND_MIN",
10048 Self::Max => "KIND_MAX",
10049 Self::Sum => "KIND_SUM",
10050 };
10051 serializer.serialize_str(variant)
10052 }
10053}
10054impl<'de> serde::Deserialize<'de> for match_recognize_measure_slot::Kind {
10055 #[allow(deprecated)]
10056 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10057 where
10058 D: serde::Deserializer<'de>,
10059 {
10060 const FIELDS: &[&str] = &[
10061 "KIND_UNSPECIFIED",
10062 "KIND_LAST",
10063 "KIND_FIRST",
10064 "KIND_CLASSIFIER",
10065 "KIND_COUNT_STAR",
10066 "KIND_COUNT",
10067 "KIND_MIN",
10068 "KIND_MAX",
10069 "KIND_SUM",
10070 ];
10071
10072 struct GeneratedVisitor;
10073
10074 impl serde::de::Visitor<'_> for GeneratedVisitor {
10075 type Value = match_recognize_measure_slot::Kind;
10076
10077 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10078 write!(formatter, "expected one of: {:?}", &FIELDS)
10079 }
10080
10081 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10082 where
10083 E: serde::de::Error,
10084 {
10085 i32::try_from(v)
10086 .ok()
10087 .and_then(|x| x.try_into().ok())
10088 .ok_or_else(|| {
10089 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10090 })
10091 }
10092
10093 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10094 where
10095 E: serde::de::Error,
10096 {
10097 i32::try_from(v)
10098 .ok()
10099 .and_then(|x| x.try_into().ok())
10100 .ok_or_else(|| {
10101 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10102 })
10103 }
10104
10105 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10106 where
10107 E: serde::de::Error,
10108 {
10109 match value {
10110 "KIND_UNSPECIFIED" => Ok(match_recognize_measure_slot::Kind::Unspecified),
10111 "KIND_LAST" => Ok(match_recognize_measure_slot::Kind::Last),
10112 "KIND_FIRST" => Ok(match_recognize_measure_slot::Kind::First),
10113 "KIND_CLASSIFIER" => Ok(match_recognize_measure_slot::Kind::Classifier),
10114 "KIND_COUNT_STAR" => Ok(match_recognize_measure_slot::Kind::CountStar),
10115 "KIND_COUNT" => Ok(match_recognize_measure_slot::Kind::Count),
10116 "KIND_MIN" => Ok(match_recognize_measure_slot::Kind::Min),
10117 "KIND_MAX" => Ok(match_recognize_measure_slot::Kind::Max),
10118 "KIND_SUM" => Ok(match_recognize_measure_slot::Kind::Sum),
10119 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10120 }
10121 }
10122 }
10123 deserializer.deserialize_any(GeneratedVisitor)
10124 }
10125}
10126impl serde::Serialize for MatchRecognizeNode {
10127 #[allow(deprecated)]
10128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10129 where
10130 S: serde::Serializer,
10131 {
10132 use serde::ser::SerializeStruct;
10133 let mut len = 0;
10134 if !self.partition_by.is_empty() {
10135 len += 1;
10136 }
10137 if !self.order_by.is_empty() {
10138 len += 1;
10139 }
10140 if !self.measures.is_empty() {
10141 len += 1;
10142 }
10143 if !self.defines.is_empty() {
10144 len += 1;
10145 }
10146 if self.pattern_node.is_some() {
10147 len += 1;
10148 }
10149 if self.state_table.is_some() {
10150 len += 1;
10151 }
10152 if self.after_match_skip.is_some() {
10153 len += 1;
10154 }
10155 if self.within.is_some() {
10156 len += 1;
10157 }
10158 if self.within_deadline.is_some() {
10159 len += 1;
10160 }
10161 if self.input_mode != 0 {
10162 len += 1;
10163 }
10164 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeNode", len)?;
10165 if !self.partition_by.is_empty() {
10166 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
10167 }
10168 if !self.order_by.is_empty() {
10169 struct_ser.serialize_field("orderBy", &self.order_by)?;
10170 }
10171 if !self.measures.is_empty() {
10172 struct_ser.serialize_field("measures", &self.measures)?;
10173 }
10174 if !self.defines.is_empty() {
10175 struct_ser.serialize_field("defines", &self.defines)?;
10176 }
10177 if let Some(v) = self.pattern_node.as_ref() {
10178 struct_ser.serialize_field("patternNode", v)?;
10179 }
10180 if let Some(v) = self.state_table.as_ref() {
10181 struct_ser.serialize_field("stateTable", v)?;
10182 }
10183 if let Some(v) = self.after_match_skip.as_ref() {
10184 struct_ser.serialize_field("afterMatchSkip", v)?;
10185 }
10186 if let Some(v) = self.within.as_ref() {
10187 struct_ser.serialize_field("within", v)?;
10188 }
10189 if let Some(v) = self.within_deadline.as_ref() {
10190 struct_ser.serialize_field("withinDeadline", v)?;
10191 }
10192 if self.input_mode != 0 {
10193 let v = MatchRecognizeInputMode::try_from(self.input_mode)
10194 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.input_mode)))?;
10195 struct_ser.serialize_field("inputMode", &v)?;
10196 }
10197 struct_ser.end()
10198 }
10199}
10200impl<'de> serde::Deserialize<'de> for MatchRecognizeNode {
10201 #[allow(deprecated)]
10202 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10203 where
10204 D: serde::Deserializer<'de>,
10205 {
10206 const FIELDS: &[&str] = &[
10207 "partition_by",
10208 "partitionBy",
10209 "order_by",
10210 "orderBy",
10211 "measures",
10212 "defines",
10213 "pattern_node",
10214 "patternNode",
10215 "state_table",
10216 "stateTable",
10217 "after_match_skip",
10218 "afterMatchSkip",
10219 "within",
10220 "within_deadline",
10221 "withinDeadline",
10222 "input_mode",
10223 "inputMode",
10224 ];
10225
10226 #[allow(clippy::enum_variant_names)]
10227 enum GeneratedField {
10228 PartitionBy,
10229 OrderBy,
10230 Measures,
10231 Defines,
10232 PatternNode,
10233 StateTable,
10234 AfterMatchSkip,
10235 Within,
10236 WithinDeadline,
10237 InputMode,
10238 }
10239 impl<'de> serde::Deserialize<'de> for GeneratedField {
10240 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10241 where
10242 D: serde::Deserializer<'de>,
10243 {
10244 struct GeneratedVisitor;
10245
10246 impl serde::de::Visitor<'_> for GeneratedVisitor {
10247 type Value = GeneratedField;
10248
10249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10250 write!(formatter, "expected one of: {:?}", &FIELDS)
10251 }
10252
10253 #[allow(unused_variables)]
10254 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10255 where
10256 E: serde::de::Error,
10257 {
10258 match value {
10259 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
10260 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
10261 "measures" => Ok(GeneratedField::Measures),
10262 "defines" => Ok(GeneratedField::Defines),
10263 "patternNode" | "pattern_node" => Ok(GeneratedField::PatternNode),
10264 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10265 "afterMatchSkip" | "after_match_skip" => Ok(GeneratedField::AfterMatchSkip),
10266 "within" => Ok(GeneratedField::Within),
10267 "withinDeadline" | "within_deadline" => Ok(GeneratedField::WithinDeadline),
10268 "inputMode" | "input_mode" => Ok(GeneratedField::InputMode),
10269 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10270 }
10271 }
10272 }
10273 deserializer.deserialize_identifier(GeneratedVisitor)
10274 }
10275 }
10276 struct GeneratedVisitor;
10277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10278 type Value = MatchRecognizeNode;
10279
10280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10281 formatter.write_str("struct stream_plan.MatchRecognizeNode")
10282 }
10283
10284 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeNode, V::Error>
10285 where
10286 V: serde::de::MapAccess<'de>,
10287 {
10288 let mut partition_by__ = None;
10289 let mut order_by__ = None;
10290 let mut measures__ = None;
10291 let mut defines__ = None;
10292 let mut pattern_node__ = None;
10293 let mut state_table__ = None;
10294 let mut after_match_skip__ = None;
10295 let mut within__ = None;
10296 let mut within_deadline__ = None;
10297 let mut input_mode__ = None;
10298 while let Some(k) = map_.next_key()? {
10299 match k {
10300 GeneratedField::PartitionBy => {
10301 if partition_by__.is_some() {
10302 return Err(serde::de::Error::duplicate_field("partitionBy"));
10303 }
10304 partition_by__ =
10305 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10306 .into_iter().map(|x| x.0).collect())
10307 ;
10308 }
10309 GeneratedField::OrderBy => {
10310 if order_by__.is_some() {
10311 return Err(serde::de::Error::duplicate_field("orderBy"));
10312 }
10313 order_by__ = Some(map_.next_value()?);
10314 }
10315 GeneratedField::Measures => {
10316 if measures__.is_some() {
10317 return Err(serde::de::Error::duplicate_field("measures"));
10318 }
10319 measures__ = Some(map_.next_value()?);
10320 }
10321 GeneratedField::Defines => {
10322 if defines__.is_some() {
10323 return Err(serde::de::Error::duplicate_field("defines"));
10324 }
10325 defines__ = Some(map_.next_value()?);
10326 }
10327 GeneratedField::PatternNode => {
10328 if pattern_node__.is_some() {
10329 return Err(serde::de::Error::duplicate_field("patternNode"));
10330 }
10331 pattern_node__ = map_.next_value()?;
10332 }
10333 GeneratedField::StateTable => {
10334 if state_table__.is_some() {
10335 return Err(serde::de::Error::duplicate_field("stateTable"));
10336 }
10337 state_table__ = map_.next_value()?;
10338 }
10339 GeneratedField::AfterMatchSkip => {
10340 if after_match_skip__.is_some() {
10341 return Err(serde::de::Error::duplicate_field("afterMatchSkip"));
10342 }
10343 after_match_skip__ = map_.next_value()?;
10344 }
10345 GeneratedField::Within => {
10346 if within__.is_some() {
10347 return Err(serde::de::Error::duplicate_field("within"));
10348 }
10349 within__ = map_.next_value()?;
10350 }
10351 GeneratedField::WithinDeadline => {
10352 if within_deadline__.is_some() {
10353 return Err(serde::de::Error::duplicate_field("withinDeadline"));
10354 }
10355 within_deadline__ = map_.next_value()?;
10356 }
10357 GeneratedField::InputMode => {
10358 if input_mode__.is_some() {
10359 return Err(serde::de::Error::duplicate_field("inputMode"));
10360 }
10361 input_mode__ = Some(map_.next_value::<MatchRecognizeInputMode>()? as i32);
10362 }
10363 }
10364 }
10365 Ok(MatchRecognizeNode {
10366 partition_by: partition_by__.unwrap_or_default(),
10367 order_by: order_by__.unwrap_or_default(),
10368 measures: measures__.unwrap_or_default(),
10369 defines: defines__.unwrap_or_default(),
10370 pattern_node: pattern_node__,
10371 state_table: state_table__,
10372 after_match_skip: after_match_skip__,
10373 within: within__,
10374 within_deadline: within_deadline__,
10375 input_mode: input_mode__.unwrap_or_default(),
10376 })
10377 }
10378 }
10379 deserializer.deserialize_struct("stream_plan.MatchRecognizeNode", FIELDS, GeneratedVisitor)
10380 }
10381}
10382impl serde::Serialize for MatchRecognizePatternNode {
10383 #[allow(deprecated)]
10384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10385 where
10386 S: serde::Serializer,
10387 {
10388 use serde::ser::SerializeStruct;
10389 let mut len = 0;
10390 if self.node.is_some() {
10391 len += 1;
10392 }
10393 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePatternNode", len)?;
10394 if let Some(v) = self.node.as_ref() {
10395 match v {
10396 match_recognize_pattern_node::Node::Var(v) => {
10397 struct_ser.serialize_field("var", v)?;
10398 }
10399 match_recognize_pattern_node::Node::Concat(v) => {
10400 struct_ser.serialize_field("concat", v)?;
10401 }
10402 match_recognize_pattern_node::Node::Alternation(v) => {
10403 struct_ser.serialize_field("alternation", v)?;
10404 }
10405 match_recognize_pattern_node::Node::Quantified(v) => {
10406 struct_ser.serialize_field("quantified", v)?;
10407 }
10408 match_recognize_pattern_node::Node::Permute(v) => {
10409 struct_ser.serialize_field("permute", v)?;
10410 }
10411 }
10412 }
10413 struct_ser.end()
10414 }
10415}
10416impl<'de> serde::Deserialize<'de> for MatchRecognizePatternNode {
10417 #[allow(deprecated)]
10418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10419 where
10420 D: serde::Deserializer<'de>,
10421 {
10422 const FIELDS: &[&str] = &[
10423 "var",
10424 "concat",
10425 "alternation",
10426 "quantified",
10427 "permute",
10428 ];
10429
10430 #[allow(clippy::enum_variant_names)]
10431 enum GeneratedField {
10432 Var,
10433 Concat,
10434 Alternation,
10435 Quantified,
10436 Permute,
10437 }
10438 impl<'de> serde::Deserialize<'de> for GeneratedField {
10439 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10440 where
10441 D: serde::Deserializer<'de>,
10442 {
10443 struct GeneratedVisitor;
10444
10445 impl serde::de::Visitor<'_> for GeneratedVisitor {
10446 type Value = GeneratedField;
10447
10448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10449 write!(formatter, "expected one of: {:?}", &FIELDS)
10450 }
10451
10452 #[allow(unused_variables)]
10453 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10454 where
10455 E: serde::de::Error,
10456 {
10457 match value {
10458 "var" => Ok(GeneratedField::Var),
10459 "concat" => Ok(GeneratedField::Concat),
10460 "alternation" => Ok(GeneratedField::Alternation),
10461 "quantified" => Ok(GeneratedField::Quantified),
10462 "permute" => Ok(GeneratedField::Permute),
10463 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10464 }
10465 }
10466 }
10467 deserializer.deserialize_identifier(GeneratedVisitor)
10468 }
10469 }
10470 struct GeneratedVisitor;
10471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10472 type Value = MatchRecognizePatternNode;
10473
10474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10475 formatter.write_str("struct stream_plan.MatchRecognizePatternNode")
10476 }
10477
10478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePatternNode, V::Error>
10479 where
10480 V: serde::de::MapAccess<'de>,
10481 {
10482 let mut node__ = None;
10483 while let Some(k) = map_.next_key()? {
10484 match k {
10485 GeneratedField::Var => {
10486 if node__.is_some() {
10487 return Err(serde::de::Error::duplicate_field("var"));
10488 }
10489 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Var);
10490 }
10491 GeneratedField::Concat => {
10492 if node__.is_some() {
10493 return Err(serde::de::Error::duplicate_field("concat"));
10494 }
10495 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Concat)
10496;
10497 }
10498 GeneratedField::Alternation => {
10499 if node__.is_some() {
10500 return Err(serde::de::Error::duplicate_field("alternation"));
10501 }
10502 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Alternation)
10503;
10504 }
10505 GeneratedField::Quantified => {
10506 if node__.is_some() {
10507 return Err(serde::de::Error::duplicate_field("quantified"));
10508 }
10509 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Quantified)
10510;
10511 }
10512 GeneratedField::Permute => {
10513 if node__.is_some() {
10514 return Err(serde::de::Error::duplicate_field("permute"));
10515 }
10516 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Permute)
10517;
10518 }
10519 }
10520 }
10521 Ok(MatchRecognizePatternNode {
10522 node: node__,
10523 })
10524 }
10525 }
10526 deserializer.deserialize_struct("stream_plan.MatchRecognizePatternNode", FIELDS, GeneratedVisitor)
10527 }
10528}
10529impl serde::Serialize for MatchRecognizePatternSeq {
10530 #[allow(deprecated)]
10531 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10532 where
10533 S: serde::Serializer,
10534 {
10535 use serde::ser::SerializeStruct;
10536 let mut len = 0;
10537 if !self.patterns.is_empty() {
10538 len += 1;
10539 }
10540 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePatternSeq", len)?;
10541 if !self.patterns.is_empty() {
10542 struct_ser.serialize_field("patterns", &self.patterns)?;
10543 }
10544 struct_ser.end()
10545 }
10546}
10547impl<'de> serde::Deserialize<'de> for MatchRecognizePatternSeq {
10548 #[allow(deprecated)]
10549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10550 where
10551 D: serde::Deserializer<'de>,
10552 {
10553 const FIELDS: &[&str] = &[
10554 "patterns",
10555 ];
10556
10557 #[allow(clippy::enum_variant_names)]
10558 enum GeneratedField {
10559 Patterns,
10560 }
10561 impl<'de> serde::Deserialize<'de> for GeneratedField {
10562 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10563 where
10564 D: serde::Deserializer<'de>,
10565 {
10566 struct GeneratedVisitor;
10567
10568 impl serde::de::Visitor<'_> for GeneratedVisitor {
10569 type Value = GeneratedField;
10570
10571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10572 write!(formatter, "expected one of: {:?}", &FIELDS)
10573 }
10574
10575 #[allow(unused_variables)]
10576 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10577 where
10578 E: serde::de::Error,
10579 {
10580 match value {
10581 "patterns" => Ok(GeneratedField::Patterns),
10582 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10583 }
10584 }
10585 }
10586 deserializer.deserialize_identifier(GeneratedVisitor)
10587 }
10588 }
10589 struct GeneratedVisitor;
10590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10591 type Value = MatchRecognizePatternSeq;
10592
10593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10594 formatter.write_str("struct stream_plan.MatchRecognizePatternSeq")
10595 }
10596
10597 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePatternSeq, V::Error>
10598 where
10599 V: serde::de::MapAccess<'de>,
10600 {
10601 let mut patterns__ = None;
10602 while let Some(k) = map_.next_key()? {
10603 match k {
10604 GeneratedField::Patterns => {
10605 if patterns__.is_some() {
10606 return Err(serde::de::Error::duplicate_field("patterns"));
10607 }
10608 patterns__ = Some(map_.next_value()?);
10609 }
10610 }
10611 }
10612 Ok(MatchRecognizePatternSeq {
10613 patterns: patterns__.unwrap_or_default(),
10614 })
10615 }
10616 }
10617 deserializer.deserialize_struct("stream_plan.MatchRecognizePatternSeq", FIELDS, GeneratedVisitor)
10618 }
10619}
10620impl serde::Serialize for MatchRecognizePermutePattern {
10621 #[allow(deprecated)]
10622 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10623 where
10624 S: serde::Serializer,
10625 {
10626 use serde::ser::SerializeStruct;
10627 let mut len = 0;
10628 if !self.vars.is_empty() {
10629 len += 1;
10630 }
10631 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePermutePattern", len)?;
10632 if !self.vars.is_empty() {
10633 struct_ser.serialize_field("vars", &self.vars)?;
10634 }
10635 struct_ser.end()
10636 }
10637}
10638impl<'de> serde::Deserialize<'de> for MatchRecognizePermutePattern {
10639 #[allow(deprecated)]
10640 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10641 where
10642 D: serde::Deserializer<'de>,
10643 {
10644 const FIELDS: &[&str] = &[
10645 "vars",
10646 ];
10647
10648 #[allow(clippy::enum_variant_names)]
10649 enum GeneratedField {
10650 Vars,
10651 }
10652 impl<'de> serde::Deserialize<'de> for GeneratedField {
10653 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10654 where
10655 D: serde::Deserializer<'de>,
10656 {
10657 struct GeneratedVisitor;
10658
10659 impl serde::de::Visitor<'_> for GeneratedVisitor {
10660 type Value = GeneratedField;
10661
10662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10663 write!(formatter, "expected one of: {:?}", &FIELDS)
10664 }
10665
10666 #[allow(unused_variables)]
10667 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10668 where
10669 E: serde::de::Error,
10670 {
10671 match value {
10672 "vars" => Ok(GeneratedField::Vars),
10673 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10674 }
10675 }
10676 }
10677 deserializer.deserialize_identifier(GeneratedVisitor)
10678 }
10679 }
10680 struct GeneratedVisitor;
10681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10682 type Value = MatchRecognizePermutePattern;
10683
10684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10685 formatter.write_str("struct stream_plan.MatchRecognizePermutePattern")
10686 }
10687
10688 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePermutePattern, V::Error>
10689 where
10690 V: serde::de::MapAccess<'de>,
10691 {
10692 let mut vars__ = None;
10693 while let Some(k) = map_.next_key()? {
10694 match k {
10695 GeneratedField::Vars => {
10696 if vars__.is_some() {
10697 return Err(serde::de::Error::duplicate_field("vars"));
10698 }
10699 vars__ = Some(map_.next_value()?);
10700 }
10701 }
10702 }
10703 Ok(MatchRecognizePermutePattern {
10704 vars: vars__.unwrap_or_default(),
10705 })
10706 }
10707 }
10708 deserializer.deserialize_struct("stream_plan.MatchRecognizePermutePattern", FIELDS, GeneratedVisitor)
10709 }
10710}
10711impl serde::Serialize for MatchRecognizeQuantifiedPattern {
10712 #[allow(deprecated)]
10713 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10714 where
10715 S: serde::Serializer,
10716 {
10717 use serde::ser::SerializeStruct;
10718 let mut len = 0;
10719 if self.inner.is_some() {
10720 len += 1;
10721 }
10722 if self.quantifier.is_some() {
10723 len += 1;
10724 }
10725 if self.reluctant {
10726 len += 1;
10727 }
10728 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeQuantifiedPattern", len)?;
10729 if let Some(v) = self.inner.as_ref() {
10730 struct_ser.serialize_field("inner", v)?;
10731 }
10732 if let Some(v) = self.quantifier.as_ref() {
10733 struct_ser.serialize_field("quantifier", v)?;
10734 }
10735 if self.reluctant {
10736 struct_ser.serialize_field("reluctant", &self.reluctant)?;
10737 }
10738 struct_ser.end()
10739 }
10740}
10741impl<'de> serde::Deserialize<'de> for MatchRecognizeQuantifiedPattern {
10742 #[allow(deprecated)]
10743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10744 where
10745 D: serde::Deserializer<'de>,
10746 {
10747 const FIELDS: &[&str] = &[
10748 "inner",
10749 "quantifier",
10750 "reluctant",
10751 ];
10752
10753 #[allow(clippy::enum_variant_names)]
10754 enum GeneratedField {
10755 Inner,
10756 Quantifier,
10757 Reluctant,
10758 }
10759 impl<'de> serde::Deserialize<'de> for GeneratedField {
10760 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10761 where
10762 D: serde::Deserializer<'de>,
10763 {
10764 struct GeneratedVisitor;
10765
10766 impl serde::de::Visitor<'_> for GeneratedVisitor {
10767 type Value = GeneratedField;
10768
10769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10770 write!(formatter, "expected one of: {:?}", &FIELDS)
10771 }
10772
10773 #[allow(unused_variables)]
10774 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10775 where
10776 E: serde::de::Error,
10777 {
10778 match value {
10779 "inner" => Ok(GeneratedField::Inner),
10780 "quantifier" => Ok(GeneratedField::Quantifier),
10781 "reluctant" => Ok(GeneratedField::Reluctant),
10782 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10783 }
10784 }
10785 }
10786 deserializer.deserialize_identifier(GeneratedVisitor)
10787 }
10788 }
10789 struct GeneratedVisitor;
10790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10791 type Value = MatchRecognizeQuantifiedPattern;
10792
10793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10794 formatter.write_str("struct stream_plan.MatchRecognizeQuantifiedPattern")
10795 }
10796
10797 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeQuantifiedPattern, V::Error>
10798 where
10799 V: serde::de::MapAccess<'de>,
10800 {
10801 let mut inner__ = None;
10802 let mut quantifier__ = None;
10803 let mut reluctant__ = None;
10804 while let Some(k) = map_.next_key()? {
10805 match k {
10806 GeneratedField::Inner => {
10807 if inner__.is_some() {
10808 return Err(serde::de::Error::duplicate_field("inner"));
10809 }
10810 inner__ = map_.next_value()?;
10811 }
10812 GeneratedField::Quantifier => {
10813 if quantifier__.is_some() {
10814 return Err(serde::de::Error::duplicate_field("quantifier"));
10815 }
10816 quantifier__ = map_.next_value()?;
10817 }
10818 GeneratedField::Reluctant => {
10819 if reluctant__.is_some() {
10820 return Err(serde::de::Error::duplicate_field("reluctant"));
10821 }
10822 reluctant__ = Some(map_.next_value()?);
10823 }
10824 }
10825 }
10826 Ok(MatchRecognizeQuantifiedPattern {
10827 inner: inner__,
10828 quantifier: quantifier__,
10829 reluctant: reluctant__.unwrap_or_default(),
10830 })
10831 }
10832 }
10833 deserializer.deserialize_struct("stream_plan.MatchRecognizeQuantifiedPattern", FIELDS, GeneratedVisitor)
10834 }
10835}
10836impl serde::Serialize for MatchRecognizeQuantifier {
10837 #[allow(deprecated)]
10838 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10839 where
10840 S: serde::Serializer,
10841 {
10842 use serde::ser::SerializeStruct;
10843 let mut len = 0;
10844 if self.kind != 0 {
10845 len += 1;
10846 }
10847 if self.min != 0 {
10848 len += 1;
10849 }
10850 if self.max.is_some() {
10851 len += 1;
10852 }
10853 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeQuantifier", len)?;
10854 if self.kind != 0 {
10855 let v = match_recognize_quantifier::Kind::try_from(self.kind)
10856 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
10857 struct_ser.serialize_field("kind", &v)?;
10858 }
10859 if self.min != 0 {
10860 struct_ser.serialize_field("min", &self.min)?;
10861 }
10862 if let Some(v) = self.max.as_ref() {
10863 struct_ser.serialize_field("max", v)?;
10864 }
10865 struct_ser.end()
10866 }
10867}
10868impl<'de> serde::Deserialize<'de> for MatchRecognizeQuantifier {
10869 #[allow(deprecated)]
10870 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10871 where
10872 D: serde::Deserializer<'de>,
10873 {
10874 const FIELDS: &[&str] = &[
10875 "kind",
10876 "min",
10877 "max",
10878 ];
10879
10880 #[allow(clippy::enum_variant_names)]
10881 enum GeneratedField {
10882 Kind,
10883 Min,
10884 Max,
10885 }
10886 impl<'de> serde::Deserialize<'de> for GeneratedField {
10887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10888 where
10889 D: serde::Deserializer<'de>,
10890 {
10891 struct GeneratedVisitor;
10892
10893 impl serde::de::Visitor<'_> for GeneratedVisitor {
10894 type Value = GeneratedField;
10895
10896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10897 write!(formatter, "expected one of: {:?}", &FIELDS)
10898 }
10899
10900 #[allow(unused_variables)]
10901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10902 where
10903 E: serde::de::Error,
10904 {
10905 match value {
10906 "kind" => Ok(GeneratedField::Kind),
10907 "min" => Ok(GeneratedField::Min),
10908 "max" => Ok(GeneratedField::Max),
10909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10910 }
10911 }
10912 }
10913 deserializer.deserialize_identifier(GeneratedVisitor)
10914 }
10915 }
10916 struct GeneratedVisitor;
10917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10918 type Value = MatchRecognizeQuantifier;
10919
10920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10921 formatter.write_str("struct stream_plan.MatchRecognizeQuantifier")
10922 }
10923
10924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeQuantifier, V::Error>
10925 where
10926 V: serde::de::MapAccess<'de>,
10927 {
10928 let mut kind__ = None;
10929 let mut min__ = None;
10930 let mut max__ = None;
10931 while let Some(k) = map_.next_key()? {
10932 match k {
10933 GeneratedField::Kind => {
10934 if kind__.is_some() {
10935 return Err(serde::de::Error::duplicate_field("kind"));
10936 }
10937 kind__ = Some(map_.next_value::<match_recognize_quantifier::Kind>()? as i32);
10938 }
10939 GeneratedField::Min => {
10940 if min__.is_some() {
10941 return Err(serde::de::Error::duplicate_field("min"));
10942 }
10943 min__ =
10944 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10945 ;
10946 }
10947 GeneratedField::Max => {
10948 if max__.is_some() {
10949 return Err(serde::de::Error::duplicate_field("max"));
10950 }
10951 max__ =
10952 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10953 ;
10954 }
10955 }
10956 }
10957 Ok(MatchRecognizeQuantifier {
10958 kind: kind__.unwrap_or_default(),
10959 min: min__.unwrap_or_default(),
10960 max: max__,
10961 })
10962 }
10963 }
10964 deserializer.deserialize_struct("stream_plan.MatchRecognizeQuantifier", FIELDS, GeneratedVisitor)
10965 }
10966}
10967impl serde::Serialize for match_recognize_quantifier::Kind {
10968 #[allow(deprecated)]
10969 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10970 where
10971 S: serde::Serializer,
10972 {
10973 let variant = match self {
10974 Self::Unspecified => "KIND_UNSPECIFIED",
10975 Self::Star => "KIND_STAR",
10976 Self::Plus => "KIND_PLUS",
10977 Self::Question => "KIND_QUESTION",
10978 Self::Range => "KIND_RANGE",
10979 };
10980 serializer.serialize_str(variant)
10981 }
10982}
10983impl<'de> serde::Deserialize<'de> for match_recognize_quantifier::Kind {
10984 #[allow(deprecated)]
10985 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10986 where
10987 D: serde::Deserializer<'de>,
10988 {
10989 const FIELDS: &[&str] = &[
10990 "KIND_UNSPECIFIED",
10991 "KIND_STAR",
10992 "KIND_PLUS",
10993 "KIND_QUESTION",
10994 "KIND_RANGE",
10995 ];
10996
10997 struct GeneratedVisitor;
10998
10999 impl serde::de::Visitor<'_> for GeneratedVisitor {
11000 type Value = match_recognize_quantifier::Kind;
11001
11002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11003 write!(formatter, "expected one of: {:?}", &FIELDS)
11004 }
11005
11006 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11007 where
11008 E: serde::de::Error,
11009 {
11010 i32::try_from(v)
11011 .ok()
11012 .and_then(|x| x.try_into().ok())
11013 .ok_or_else(|| {
11014 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11015 })
11016 }
11017
11018 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11019 where
11020 E: serde::de::Error,
11021 {
11022 i32::try_from(v)
11023 .ok()
11024 .and_then(|x| x.try_into().ok())
11025 .ok_or_else(|| {
11026 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11027 })
11028 }
11029
11030 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11031 where
11032 E: serde::de::Error,
11033 {
11034 match value {
11035 "KIND_UNSPECIFIED" => Ok(match_recognize_quantifier::Kind::Unspecified),
11036 "KIND_STAR" => Ok(match_recognize_quantifier::Kind::Star),
11037 "KIND_PLUS" => Ok(match_recognize_quantifier::Kind::Plus),
11038 "KIND_QUESTION" => Ok(match_recognize_quantifier::Kind::Question),
11039 "KIND_RANGE" => Ok(match_recognize_quantifier::Kind::Range),
11040 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11041 }
11042 }
11043 }
11044 deserializer.deserialize_any(GeneratedVisitor)
11045 }
11046}
11047impl serde::Serialize for MaterializeNode {
11048 #[allow(deprecated)]
11049 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11050 where
11051 S: serde::Serializer,
11052 {
11053 use serde::ser::SerializeStruct;
11054 let mut len = 0;
11055 if self.table_id != 0 {
11056 len += 1;
11057 }
11058 if !self.column_orders.is_empty() {
11059 len += 1;
11060 }
11061 if self.table.is_some() {
11062 len += 1;
11063 }
11064 if self.staging_table.is_some() {
11065 len += 1;
11066 }
11067 if self.refresh_progress_table.is_some() {
11068 len += 1;
11069 }
11070 if self.cleaned_by_ttl_watermark {
11071 len += 1;
11072 }
11073 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
11074 if self.table_id != 0 {
11075 struct_ser.serialize_field("tableId", &self.table_id)?;
11076 }
11077 if !self.column_orders.is_empty() {
11078 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
11079 }
11080 if let Some(v) = self.table.as_ref() {
11081 struct_ser.serialize_field("table", v)?;
11082 }
11083 if let Some(v) = self.staging_table.as_ref() {
11084 struct_ser.serialize_field("stagingTable", v)?;
11085 }
11086 if let Some(v) = self.refresh_progress_table.as_ref() {
11087 struct_ser.serialize_field("refreshProgressTable", v)?;
11088 }
11089 if self.cleaned_by_ttl_watermark {
11090 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
11091 }
11092 struct_ser.end()
11093 }
11094}
11095impl<'de> serde::Deserialize<'de> for MaterializeNode {
11096 #[allow(deprecated)]
11097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11098 where
11099 D: serde::Deserializer<'de>,
11100 {
11101 const FIELDS: &[&str] = &[
11102 "table_id",
11103 "tableId",
11104 "column_orders",
11105 "columnOrders",
11106 "table",
11107 "staging_table",
11108 "stagingTable",
11109 "refresh_progress_table",
11110 "refreshProgressTable",
11111 "cleaned_by_ttl_watermark",
11112 "cleanedByTtlWatermark",
11113 ];
11114
11115 #[allow(clippy::enum_variant_names)]
11116 enum GeneratedField {
11117 TableId,
11118 ColumnOrders,
11119 Table,
11120 StagingTable,
11121 RefreshProgressTable,
11122 CleanedByTtlWatermark,
11123 }
11124 impl<'de> serde::Deserialize<'de> for GeneratedField {
11125 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11126 where
11127 D: serde::Deserializer<'de>,
11128 {
11129 struct GeneratedVisitor;
11130
11131 impl serde::de::Visitor<'_> for GeneratedVisitor {
11132 type Value = GeneratedField;
11133
11134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11135 write!(formatter, "expected one of: {:?}", &FIELDS)
11136 }
11137
11138 #[allow(unused_variables)]
11139 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11140 where
11141 E: serde::de::Error,
11142 {
11143 match value {
11144 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11145 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
11146 "table" => Ok(GeneratedField::Table),
11147 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
11148 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
11149 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
11150 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11151 }
11152 }
11153 }
11154 deserializer.deserialize_identifier(GeneratedVisitor)
11155 }
11156 }
11157 struct GeneratedVisitor;
11158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11159 type Value = MaterializeNode;
11160
11161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11162 formatter.write_str("struct stream_plan.MaterializeNode")
11163 }
11164
11165 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
11166 where
11167 V: serde::de::MapAccess<'de>,
11168 {
11169 let mut table_id__ = None;
11170 let mut column_orders__ = None;
11171 let mut table__ = None;
11172 let mut staging_table__ = None;
11173 let mut refresh_progress_table__ = None;
11174 let mut cleaned_by_ttl_watermark__ = None;
11175 while let Some(k) = map_.next_key()? {
11176 match k {
11177 GeneratedField::TableId => {
11178 if table_id__.is_some() {
11179 return Err(serde::de::Error::duplicate_field("tableId"));
11180 }
11181 table_id__ =
11182 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11183 ;
11184 }
11185 GeneratedField::ColumnOrders => {
11186 if column_orders__.is_some() {
11187 return Err(serde::de::Error::duplicate_field("columnOrders"));
11188 }
11189 column_orders__ = Some(map_.next_value()?);
11190 }
11191 GeneratedField::Table => {
11192 if table__.is_some() {
11193 return Err(serde::de::Error::duplicate_field("table"));
11194 }
11195 table__ = map_.next_value()?;
11196 }
11197 GeneratedField::StagingTable => {
11198 if staging_table__.is_some() {
11199 return Err(serde::de::Error::duplicate_field("stagingTable"));
11200 }
11201 staging_table__ = map_.next_value()?;
11202 }
11203 GeneratedField::RefreshProgressTable => {
11204 if refresh_progress_table__.is_some() {
11205 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
11206 }
11207 refresh_progress_table__ = map_.next_value()?;
11208 }
11209 GeneratedField::CleanedByTtlWatermark => {
11210 if cleaned_by_ttl_watermark__.is_some() {
11211 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
11212 }
11213 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
11214 }
11215 }
11216 }
11217 Ok(MaterializeNode {
11218 table_id: table_id__.unwrap_or_default(),
11219 column_orders: column_orders__.unwrap_or_default(),
11220 table: table__,
11221 staging_table: staging_table__,
11222 refresh_progress_table: refresh_progress_table__,
11223 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
11224 })
11225 }
11226 }
11227 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
11228 }
11229}
11230impl serde::Serialize for MaterializedExprsNode {
11231 #[allow(deprecated)]
11232 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11233 where
11234 S: serde::Serializer,
11235 {
11236 use serde::ser::SerializeStruct;
11237 let mut len = 0;
11238 if !self.exprs.is_empty() {
11239 len += 1;
11240 }
11241 if self.state_table.is_some() {
11242 len += 1;
11243 }
11244 if self.state_clean_col_idx.is_some() {
11245 len += 1;
11246 }
11247 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
11248 if !self.exprs.is_empty() {
11249 struct_ser.serialize_field("exprs", &self.exprs)?;
11250 }
11251 if let Some(v) = self.state_table.as_ref() {
11252 struct_ser.serialize_field("stateTable", v)?;
11253 }
11254 if let Some(v) = self.state_clean_col_idx.as_ref() {
11255 struct_ser.serialize_field("stateCleanColIdx", v)?;
11256 }
11257 struct_ser.end()
11258 }
11259}
11260impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
11261 #[allow(deprecated)]
11262 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11263 where
11264 D: serde::Deserializer<'de>,
11265 {
11266 const FIELDS: &[&str] = &[
11267 "exprs",
11268 "state_table",
11269 "stateTable",
11270 "state_clean_col_idx",
11271 "stateCleanColIdx",
11272 ];
11273
11274 #[allow(clippy::enum_variant_names)]
11275 enum GeneratedField {
11276 Exprs,
11277 StateTable,
11278 StateCleanColIdx,
11279 }
11280 impl<'de> serde::Deserialize<'de> for GeneratedField {
11281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11282 where
11283 D: serde::Deserializer<'de>,
11284 {
11285 struct GeneratedVisitor;
11286
11287 impl serde::de::Visitor<'_> for GeneratedVisitor {
11288 type Value = GeneratedField;
11289
11290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11291 write!(formatter, "expected one of: {:?}", &FIELDS)
11292 }
11293
11294 #[allow(unused_variables)]
11295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11296 where
11297 E: serde::de::Error,
11298 {
11299 match value {
11300 "exprs" => Ok(GeneratedField::Exprs),
11301 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11302 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
11303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11304 }
11305 }
11306 }
11307 deserializer.deserialize_identifier(GeneratedVisitor)
11308 }
11309 }
11310 struct GeneratedVisitor;
11311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11312 type Value = MaterializedExprsNode;
11313
11314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11315 formatter.write_str("struct stream_plan.MaterializedExprsNode")
11316 }
11317
11318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
11319 where
11320 V: serde::de::MapAccess<'de>,
11321 {
11322 let mut exprs__ = None;
11323 let mut state_table__ = None;
11324 let mut state_clean_col_idx__ = None;
11325 while let Some(k) = map_.next_key()? {
11326 match k {
11327 GeneratedField::Exprs => {
11328 if exprs__.is_some() {
11329 return Err(serde::de::Error::duplicate_field("exprs"));
11330 }
11331 exprs__ = Some(map_.next_value()?);
11332 }
11333 GeneratedField::StateTable => {
11334 if state_table__.is_some() {
11335 return Err(serde::de::Error::duplicate_field("stateTable"));
11336 }
11337 state_table__ = map_.next_value()?;
11338 }
11339 GeneratedField::StateCleanColIdx => {
11340 if state_clean_col_idx__.is_some() {
11341 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
11342 }
11343 state_clean_col_idx__ =
11344 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11345 ;
11346 }
11347 }
11348 }
11349 Ok(MaterializedExprsNode {
11350 exprs: exprs__.unwrap_or_default(),
11351 state_table: state_table__,
11352 state_clean_col_idx: state_clean_col_idx__,
11353 })
11354 }
11355 }
11356 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
11357 }
11358}
11359impl serde::Serialize for MergeNode {
11360 #[allow(deprecated)]
11361 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11362 where
11363 S: serde::Serializer,
11364 {
11365 use serde::ser::SerializeStruct;
11366 let mut len = 0;
11367 if !self.upstream_actor_id.is_empty() {
11368 len += 1;
11369 }
11370 if self.upstream_fragment_id != 0 {
11371 len += 1;
11372 }
11373 if self.upstream_dispatcher_type != 0 {
11374 len += 1;
11375 }
11376 if !self.fields.is_empty() {
11377 len += 1;
11378 }
11379 if self.allow_empty_upstream {
11380 len += 1;
11381 }
11382 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
11383 if !self.upstream_actor_id.is_empty() {
11384 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
11385 }
11386 if self.upstream_fragment_id != 0 {
11387 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
11388 }
11389 if self.upstream_dispatcher_type != 0 {
11390 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
11391 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
11392 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
11393 }
11394 if !self.fields.is_empty() {
11395 struct_ser.serialize_field("fields", &self.fields)?;
11396 }
11397 if self.allow_empty_upstream {
11398 struct_ser.serialize_field("allowEmptyUpstream", &self.allow_empty_upstream)?;
11399 }
11400 struct_ser.end()
11401 }
11402}
11403impl<'de> serde::Deserialize<'de> for MergeNode {
11404 #[allow(deprecated)]
11405 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11406 where
11407 D: serde::Deserializer<'de>,
11408 {
11409 const FIELDS: &[&str] = &[
11410 "upstream_actor_id",
11411 "upstreamActorId",
11412 "upstream_fragment_id",
11413 "upstreamFragmentId",
11414 "upstream_dispatcher_type",
11415 "upstreamDispatcherType",
11416 "fields",
11417 "allow_empty_upstream",
11418 "allowEmptyUpstream",
11419 ];
11420
11421 #[allow(clippy::enum_variant_names)]
11422 enum GeneratedField {
11423 UpstreamActorId,
11424 UpstreamFragmentId,
11425 UpstreamDispatcherType,
11426 Fields,
11427 AllowEmptyUpstream,
11428 }
11429 impl<'de> serde::Deserialize<'de> for GeneratedField {
11430 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11431 where
11432 D: serde::Deserializer<'de>,
11433 {
11434 struct GeneratedVisitor;
11435
11436 impl serde::de::Visitor<'_> for GeneratedVisitor {
11437 type Value = GeneratedField;
11438
11439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11440 write!(formatter, "expected one of: {:?}", &FIELDS)
11441 }
11442
11443 #[allow(unused_variables)]
11444 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11445 where
11446 E: serde::de::Error,
11447 {
11448 match value {
11449 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
11450 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
11451 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
11452 "fields" => Ok(GeneratedField::Fields),
11453 "allowEmptyUpstream" | "allow_empty_upstream" => Ok(GeneratedField::AllowEmptyUpstream),
11454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11455 }
11456 }
11457 }
11458 deserializer.deserialize_identifier(GeneratedVisitor)
11459 }
11460 }
11461 struct GeneratedVisitor;
11462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11463 type Value = MergeNode;
11464
11465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11466 formatter.write_str("struct stream_plan.MergeNode")
11467 }
11468
11469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
11470 where
11471 V: serde::de::MapAccess<'de>,
11472 {
11473 let mut upstream_actor_id__ = None;
11474 let mut upstream_fragment_id__ = None;
11475 let mut upstream_dispatcher_type__ = None;
11476 let mut fields__ = None;
11477 let mut allow_empty_upstream__ = None;
11478 while let Some(k) = map_.next_key()? {
11479 match k {
11480 GeneratedField::UpstreamActorId => {
11481 if upstream_actor_id__.is_some() {
11482 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
11483 }
11484 upstream_actor_id__ =
11485 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11486 .into_iter().map(|x| x.0).collect())
11487 ;
11488 }
11489 GeneratedField::UpstreamFragmentId => {
11490 if upstream_fragment_id__.is_some() {
11491 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
11492 }
11493 upstream_fragment_id__ =
11494 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11495 ;
11496 }
11497 GeneratedField::UpstreamDispatcherType => {
11498 if upstream_dispatcher_type__.is_some() {
11499 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
11500 }
11501 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
11502 }
11503 GeneratedField::Fields => {
11504 if fields__.is_some() {
11505 return Err(serde::de::Error::duplicate_field("fields"));
11506 }
11507 fields__ = Some(map_.next_value()?);
11508 }
11509 GeneratedField::AllowEmptyUpstream => {
11510 if allow_empty_upstream__.is_some() {
11511 return Err(serde::de::Error::duplicate_field("allowEmptyUpstream"));
11512 }
11513 allow_empty_upstream__ = Some(map_.next_value()?);
11514 }
11515 }
11516 }
11517 Ok(MergeNode {
11518 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
11519 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
11520 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
11521 fields: fields__.unwrap_or_default(),
11522 allow_empty_upstream: allow_empty_upstream__.unwrap_or_default(),
11523 })
11524 }
11525 }
11526 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
11527 }
11528}
11529impl serde::Serialize for NoOpNode {
11530 #[allow(deprecated)]
11531 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11532 where
11533 S: serde::Serializer,
11534 {
11535 use serde::ser::SerializeStruct;
11536 let len = 0;
11537 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
11538 struct_ser.end()
11539 }
11540}
11541impl<'de> serde::Deserialize<'de> for NoOpNode {
11542 #[allow(deprecated)]
11543 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11544 where
11545 D: serde::Deserializer<'de>,
11546 {
11547 const FIELDS: &[&str] = &[
11548 ];
11549
11550 #[allow(clippy::enum_variant_names)]
11551 enum GeneratedField {
11552 }
11553 impl<'de> serde::Deserialize<'de> for GeneratedField {
11554 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11555 where
11556 D: serde::Deserializer<'de>,
11557 {
11558 struct GeneratedVisitor;
11559
11560 impl serde::de::Visitor<'_> for GeneratedVisitor {
11561 type Value = GeneratedField;
11562
11563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11564 write!(formatter, "expected one of: {:?}", &FIELDS)
11565 }
11566
11567 #[allow(unused_variables)]
11568 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11569 where
11570 E: serde::de::Error,
11571 {
11572 Err(serde::de::Error::unknown_field(value, FIELDS))
11573 }
11574 }
11575 deserializer.deserialize_identifier(GeneratedVisitor)
11576 }
11577 }
11578 struct GeneratedVisitor;
11579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11580 type Value = NoOpNode;
11581
11582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11583 formatter.write_str("struct stream_plan.NoOpNode")
11584 }
11585
11586 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
11587 where
11588 V: serde::de::MapAccess<'de>,
11589 {
11590 while map_.next_key::<GeneratedField>()?.is_some() {
11591 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11592 }
11593 Ok(NoOpNode {
11594 })
11595 }
11596 }
11597 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
11598 }
11599}
11600impl serde::Serialize for NowModeGenerateSeries {
11601 #[allow(deprecated)]
11602 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11603 where
11604 S: serde::Serializer,
11605 {
11606 use serde::ser::SerializeStruct;
11607 let mut len = 0;
11608 if self.start_timestamp.is_some() {
11609 len += 1;
11610 }
11611 if self.interval.is_some() {
11612 len += 1;
11613 }
11614 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
11615 if let Some(v) = self.start_timestamp.as_ref() {
11616 struct_ser.serialize_field("startTimestamp", v)?;
11617 }
11618 if let Some(v) = self.interval.as_ref() {
11619 struct_ser.serialize_field("interval", v)?;
11620 }
11621 struct_ser.end()
11622 }
11623}
11624impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
11625 #[allow(deprecated)]
11626 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11627 where
11628 D: serde::Deserializer<'de>,
11629 {
11630 const FIELDS: &[&str] = &[
11631 "start_timestamp",
11632 "startTimestamp",
11633 "interval",
11634 ];
11635
11636 #[allow(clippy::enum_variant_names)]
11637 enum GeneratedField {
11638 StartTimestamp,
11639 Interval,
11640 }
11641 impl<'de> serde::Deserialize<'de> for GeneratedField {
11642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11643 where
11644 D: serde::Deserializer<'de>,
11645 {
11646 struct GeneratedVisitor;
11647
11648 impl serde::de::Visitor<'_> for GeneratedVisitor {
11649 type Value = GeneratedField;
11650
11651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11652 write!(formatter, "expected one of: {:?}", &FIELDS)
11653 }
11654
11655 #[allow(unused_variables)]
11656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11657 where
11658 E: serde::de::Error,
11659 {
11660 match value {
11661 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
11662 "interval" => Ok(GeneratedField::Interval),
11663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11664 }
11665 }
11666 }
11667 deserializer.deserialize_identifier(GeneratedVisitor)
11668 }
11669 }
11670 struct GeneratedVisitor;
11671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11672 type Value = NowModeGenerateSeries;
11673
11674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11675 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
11676 }
11677
11678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
11679 where
11680 V: serde::de::MapAccess<'de>,
11681 {
11682 let mut start_timestamp__ = None;
11683 let mut interval__ = None;
11684 while let Some(k) = map_.next_key()? {
11685 match k {
11686 GeneratedField::StartTimestamp => {
11687 if start_timestamp__.is_some() {
11688 return Err(serde::de::Error::duplicate_field("startTimestamp"));
11689 }
11690 start_timestamp__ = map_.next_value()?;
11691 }
11692 GeneratedField::Interval => {
11693 if interval__.is_some() {
11694 return Err(serde::de::Error::duplicate_field("interval"));
11695 }
11696 interval__ = map_.next_value()?;
11697 }
11698 }
11699 }
11700 Ok(NowModeGenerateSeries {
11701 start_timestamp: start_timestamp__,
11702 interval: interval__,
11703 })
11704 }
11705 }
11706 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
11707 }
11708}
11709impl serde::Serialize for NowModeUpdateCurrent {
11710 #[allow(deprecated)]
11711 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11712 where
11713 S: serde::Serializer,
11714 {
11715 use serde::ser::SerializeStruct;
11716 let len = 0;
11717 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
11718 struct_ser.end()
11719 }
11720}
11721impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
11722 #[allow(deprecated)]
11723 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11724 where
11725 D: serde::Deserializer<'de>,
11726 {
11727 const FIELDS: &[&str] = &[
11728 ];
11729
11730 #[allow(clippy::enum_variant_names)]
11731 enum GeneratedField {
11732 }
11733 impl<'de> serde::Deserialize<'de> for GeneratedField {
11734 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11735 where
11736 D: serde::Deserializer<'de>,
11737 {
11738 struct GeneratedVisitor;
11739
11740 impl serde::de::Visitor<'_> for GeneratedVisitor {
11741 type Value = GeneratedField;
11742
11743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11744 write!(formatter, "expected one of: {:?}", &FIELDS)
11745 }
11746
11747 #[allow(unused_variables)]
11748 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11749 where
11750 E: serde::de::Error,
11751 {
11752 Err(serde::de::Error::unknown_field(value, FIELDS))
11753 }
11754 }
11755 deserializer.deserialize_identifier(GeneratedVisitor)
11756 }
11757 }
11758 struct GeneratedVisitor;
11759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11760 type Value = NowModeUpdateCurrent;
11761
11762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11763 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
11764 }
11765
11766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
11767 where
11768 V: serde::de::MapAccess<'de>,
11769 {
11770 while map_.next_key::<GeneratedField>()?.is_some() {
11771 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11772 }
11773 Ok(NowModeUpdateCurrent {
11774 })
11775 }
11776 }
11777 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
11778 }
11779}
11780impl serde::Serialize for NowNode {
11781 #[allow(deprecated)]
11782 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11783 where
11784 S: serde::Serializer,
11785 {
11786 use serde::ser::SerializeStruct;
11787 let mut len = 0;
11788 if self.state_table.is_some() {
11789 len += 1;
11790 }
11791 if self.mode.is_some() {
11792 len += 1;
11793 }
11794 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
11795 if let Some(v) = self.state_table.as_ref() {
11796 struct_ser.serialize_field("stateTable", v)?;
11797 }
11798 if let Some(v) = self.mode.as_ref() {
11799 match v {
11800 now_node::Mode::UpdateCurrent(v) => {
11801 struct_ser.serialize_field("updateCurrent", v)?;
11802 }
11803 now_node::Mode::GenerateSeries(v) => {
11804 struct_ser.serialize_field("generateSeries", v)?;
11805 }
11806 }
11807 }
11808 struct_ser.end()
11809 }
11810}
11811impl<'de> serde::Deserialize<'de> for NowNode {
11812 #[allow(deprecated)]
11813 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11814 where
11815 D: serde::Deserializer<'de>,
11816 {
11817 const FIELDS: &[&str] = &[
11818 "state_table",
11819 "stateTable",
11820 "update_current",
11821 "updateCurrent",
11822 "generate_series",
11823 "generateSeries",
11824 ];
11825
11826 #[allow(clippy::enum_variant_names)]
11827 enum GeneratedField {
11828 StateTable,
11829 UpdateCurrent,
11830 GenerateSeries,
11831 }
11832 impl<'de> serde::Deserialize<'de> for GeneratedField {
11833 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11834 where
11835 D: serde::Deserializer<'de>,
11836 {
11837 struct GeneratedVisitor;
11838
11839 impl serde::de::Visitor<'_> for GeneratedVisitor {
11840 type Value = GeneratedField;
11841
11842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11843 write!(formatter, "expected one of: {:?}", &FIELDS)
11844 }
11845
11846 #[allow(unused_variables)]
11847 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11848 where
11849 E: serde::de::Error,
11850 {
11851 match value {
11852 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11853 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
11854 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
11855 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11856 }
11857 }
11858 }
11859 deserializer.deserialize_identifier(GeneratedVisitor)
11860 }
11861 }
11862 struct GeneratedVisitor;
11863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11864 type Value = NowNode;
11865
11866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11867 formatter.write_str("struct stream_plan.NowNode")
11868 }
11869
11870 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
11871 where
11872 V: serde::de::MapAccess<'de>,
11873 {
11874 let mut state_table__ = None;
11875 let mut mode__ = None;
11876 while let Some(k) = map_.next_key()? {
11877 match k {
11878 GeneratedField::StateTable => {
11879 if state_table__.is_some() {
11880 return Err(serde::de::Error::duplicate_field("stateTable"));
11881 }
11882 state_table__ = map_.next_value()?;
11883 }
11884 GeneratedField::UpdateCurrent => {
11885 if mode__.is_some() {
11886 return Err(serde::de::Error::duplicate_field("updateCurrent"));
11887 }
11888 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
11889;
11890 }
11891 GeneratedField::GenerateSeries => {
11892 if mode__.is_some() {
11893 return Err(serde::de::Error::duplicate_field("generateSeries"));
11894 }
11895 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
11896;
11897 }
11898 }
11899 }
11900 Ok(NowNode {
11901 state_table: state_table__,
11902 mode: mode__,
11903 })
11904 }
11905 }
11906 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
11907 }
11908}
11909impl serde::Serialize for OverWindowCachePolicy {
11910 #[allow(deprecated)]
11911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11912 where
11913 S: serde::Serializer,
11914 {
11915 let variant = match self {
11916 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
11917 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
11918 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
11919 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
11920 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
11921 };
11922 serializer.serialize_str(variant)
11923 }
11924}
11925impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
11926 #[allow(deprecated)]
11927 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11928 where
11929 D: serde::Deserializer<'de>,
11930 {
11931 const FIELDS: &[&str] = &[
11932 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
11933 "OVER_WINDOW_CACHE_POLICY_FULL",
11934 "OVER_WINDOW_CACHE_POLICY_RECENT",
11935 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
11936 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
11937 ];
11938
11939 struct GeneratedVisitor;
11940
11941 impl serde::de::Visitor<'_> for GeneratedVisitor {
11942 type Value = OverWindowCachePolicy;
11943
11944 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11945 write!(formatter, "expected one of: {:?}", &FIELDS)
11946 }
11947
11948 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11949 where
11950 E: serde::de::Error,
11951 {
11952 i32::try_from(v)
11953 .ok()
11954 .and_then(|x| x.try_into().ok())
11955 .ok_or_else(|| {
11956 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11957 })
11958 }
11959
11960 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11961 where
11962 E: serde::de::Error,
11963 {
11964 i32::try_from(v)
11965 .ok()
11966 .and_then(|x| x.try_into().ok())
11967 .ok_or_else(|| {
11968 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11969 })
11970 }
11971
11972 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11973 where
11974 E: serde::de::Error,
11975 {
11976 match value {
11977 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
11978 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
11979 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
11980 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
11981 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
11982 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11983 }
11984 }
11985 }
11986 deserializer.deserialize_any(GeneratedVisitor)
11987 }
11988}
11989impl serde::Serialize for OverWindowNode {
11990 #[allow(deprecated)]
11991 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11992 where
11993 S: serde::Serializer,
11994 {
11995 use serde::ser::SerializeStruct;
11996 let mut len = 0;
11997 if !self.calls.is_empty() {
11998 len += 1;
11999 }
12000 if !self.partition_by.is_empty() {
12001 len += 1;
12002 }
12003 if !self.order_by.is_empty() {
12004 len += 1;
12005 }
12006 if self.state_table.is_some() {
12007 len += 1;
12008 }
12009 if self.cache_policy != 0 {
12010 len += 1;
12011 }
12012 if self.enable_state_cleaning {
12013 len += 1;
12014 }
12015 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
12016 if !self.calls.is_empty() {
12017 struct_ser.serialize_field("calls", &self.calls)?;
12018 }
12019 if !self.partition_by.is_empty() {
12020 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
12021 }
12022 if !self.order_by.is_empty() {
12023 struct_ser.serialize_field("orderBy", &self.order_by)?;
12024 }
12025 if let Some(v) = self.state_table.as_ref() {
12026 struct_ser.serialize_field("stateTable", v)?;
12027 }
12028 if self.cache_policy != 0 {
12029 let v = OverWindowCachePolicy::try_from(self.cache_policy)
12030 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
12031 struct_ser.serialize_field("cachePolicy", &v)?;
12032 }
12033 if self.enable_state_cleaning {
12034 struct_ser.serialize_field("enableStateCleaning", &self.enable_state_cleaning)?;
12035 }
12036 struct_ser.end()
12037 }
12038}
12039impl<'de> serde::Deserialize<'de> for OverWindowNode {
12040 #[allow(deprecated)]
12041 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12042 where
12043 D: serde::Deserializer<'de>,
12044 {
12045 const FIELDS: &[&str] = &[
12046 "calls",
12047 "partition_by",
12048 "partitionBy",
12049 "order_by",
12050 "orderBy",
12051 "state_table",
12052 "stateTable",
12053 "cache_policy",
12054 "cachePolicy",
12055 "enable_state_cleaning",
12056 "enableStateCleaning",
12057 ];
12058
12059 #[allow(clippy::enum_variant_names)]
12060 enum GeneratedField {
12061 Calls,
12062 PartitionBy,
12063 OrderBy,
12064 StateTable,
12065 CachePolicy,
12066 EnableStateCleaning,
12067 }
12068 impl<'de> serde::Deserialize<'de> for GeneratedField {
12069 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12070 where
12071 D: serde::Deserializer<'de>,
12072 {
12073 struct GeneratedVisitor;
12074
12075 impl serde::de::Visitor<'_> for GeneratedVisitor {
12076 type Value = GeneratedField;
12077
12078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12079 write!(formatter, "expected one of: {:?}", &FIELDS)
12080 }
12081
12082 #[allow(unused_variables)]
12083 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12084 where
12085 E: serde::de::Error,
12086 {
12087 match value {
12088 "calls" => Ok(GeneratedField::Calls),
12089 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
12090 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
12091 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12092 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
12093 "enableStateCleaning" | "enable_state_cleaning" => Ok(GeneratedField::EnableStateCleaning),
12094 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12095 }
12096 }
12097 }
12098 deserializer.deserialize_identifier(GeneratedVisitor)
12099 }
12100 }
12101 struct GeneratedVisitor;
12102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12103 type Value = OverWindowNode;
12104
12105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12106 formatter.write_str("struct stream_plan.OverWindowNode")
12107 }
12108
12109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
12110 where
12111 V: serde::de::MapAccess<'de>,
12112 {
12113 let mut calls__ = None;
12114 let mut partition_by__ = None;
12115 let mut order_by__ = None;
12116 let mut state_table__ = None;
12117 let mut cache_policy__ = None;
12118 let mut enable_state_cleaning__ = None;
12119 while let Some(k) = map_.next_key()? {
12120 match k {
12121 GeneratedField::Calls => {
12122 if calls__.is_some() {
12123 return Err(serde::de::Error::duplicate_field("calls"));
12124 }
12125 calls__ = Some(map_.next_value()?);
12126 }
12127 GeneratedField::PartitionBy => {
12128 if partition_by__.is_some() {
12129 return Err(serde::de::Error::duplicate_field("partitionBy"));
12130 }
12131 partition_by__ =
12132 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12133 .into_iter().map(|x| x.0).collect())
12134 ;
12135 }
12136 GeneratedField::OrderBy => {
12137 if order_by__.is_some() {
12138 return Err(serde::de::Error::duplicate_field("orderBy"));
12139 }
12140 order_by__ = Some(map_.next_value()?);
12141 }
12142 GeneratedField::StateTable => {
12143 if state_table__.is_some() {
12144 return Err(serde::de::Error::duplicate_field("stateTable"));
12145 }
12146 state_table__ = map_.next_value()?;
12147 }
12148 GeneratedField::CachePolicy => {
12149 if cache_policy__.is_some() {
12150 return Err(serde::de::Error::duplicate_field("cachePolicy"));
12151 }
12152 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
12153 }
12154 GeneratedField::EnableStateCleaning => {
12155 if enable_state_cleaning__.is_some() {
12156 return Err(serde::de::Error::duplicate_field("enableStateCleaning"));
12157 }
12158 enable_state_cleaning__ = Some(map_.next_value()?);
12159 }
12160 }
12161 }
12162 Ok(OverWindowNode {
12163 calls: calls__.unwrap_or_default(),
12164 partition_by: partition_by__.unwrap_or_default(),
12165 order_by: order_by__.unwrap_or_default(),
12166 state_table: state_table__,
12167 cache_policy: cache_policy__.unwrap_or_default(),
12168 enable_state_cleaning: enable_state_cleaning__.unwrap_or_default(),
12169 })
12170 }
12171 }
12172 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
12173 }
12174}
12175impl serde::Serialize for PauseMutation {
12176 #[allow(deprecated)]
12177 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12178 where
12179 S: serde::Serializer,
12180 {
12181 use serde::ser::SerializeStruct;
12182 let len = 0;
12183 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
12184 struct_ser.end()
12185 }
12186}
12187impl<'de> serde::Deserialize<'de> for PauseMutation {
12188 #[allow(deprecated)]
12189 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12190 where
12191 D: serde::Deserializer<'de>,
12192 {
12193 const FIELDS: &[&str] = &[
12194 ];
12195
12196 #[allow(clippy::enum_variant_names)]
12197 enum GeneratedField {
12198 }
12199 impl<'de> serde::Deserialize<'de> for GeneratedField {
12200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12201 where
12202 D: serde::Deserializer<'de>,
12203 {
12204 struct GeneratedVisitor;
12205
12206 impl serde::de::Visitor<'_> for GeneratedVisitor {
12207 type Value = GeneratedField;
12208
12209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12210 write!(formatter, "expected one of: {:?}", &FIELDS)
12211 }
12212
12213 #[allow(unused_variables)]
12214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12215 where
12216 E: serde::de::Error,
12217 {
12218 Err(serde::de::Error::unknown_field(value, FIELDS))
12219 }
12220 }
12221 deserializer.deserialize_identifier(GeneratedVisitor)
12222 }
12223 }
12224 struct GeneratedVisitor;
12225 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12226 type Value = PauseMutation;
12227
12228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12229 formatter.write_str("struct stream_plan.PauseMutation")
12230 }
12231
12232 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
12233 where
12234 V: serde::de::MapAccess<'de>,
12235 {
12236 while map_.next_key::<GeneratedField>()?.is_some() {
12237 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12238 }
12239 Ok(PauseMutation {
12240 })
12241 }
12242 }
12243 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
12244 }
12245}
12246impl serde::Serialize for ProjectNode {
12247 #[allow(deprecated)]
12248 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12249 where
12250 S: serde::Serializer,
12251 {
12252 use serde::ser::SerializeStruct;
12253 let mut len = 0;
12254 if !self.select_list.is_empty() {
12255 len += 1;
12256 }
12257 if !self.watermark_input_cols.is_empty() {
12258 len += 1;
12259 }
12260 if !self.watermark_output_cols.is_empty() {
12261 len += 1;
12262 }
12263 if !self.nondecreasing_exprs.is_empty() {
12264 len += 1;
12265 }
12266 if self.noop_update_hint {
12267 len += 1;
12268 }
12269 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
12270 if !self.select_list.is_empty() {
12271 struct_ser.serialize_field("selectList", &self.select_list)?;
12272 }
12273 if !self.watermark_input_cols.is_empty() {
12274 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
12275 }
12276 if !self.watermark_output_cols.is_empty() {
12277 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
12278 }
12279 if !self.nondecreasing_exprs.is_empty() {
12280 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
12281 }
12282 if self.noop_update_hint {
12283 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
12284 }
12285 struct_ser.end()
12286 }
12287}
12288impl<'de> serde::Deserialize<'de> for ProjectNode {
12289 #[allow(deprecated)]
12290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12291 where
12292 D: serde::Deserializer<'de>,
12293 {
12294 const FIELDS: &[&str] = &[
12295 "select_list",
12296 "selectList",
12297 "watermark_input_cols",
12298 "watermarkInputCols",
12299 "watermark_output_cols",
12300 "watermarkOutputCols",
12301 "nondecreasing_exprs",
12302 "nondecreasingExprs",
12303 "noop_update_hint",
12304 "noopUpdateHint",
12305 ];
12306
12307 #[allow(clippy::enum_variant_names)]
12308 enum GeneratedField {
12309 SelectList,
12310 WatermarkInputCols,
12311 WatermarkOutputCols,
12312 NondecreasingExprs,
12313 NoopUpdateHint,
12314 }
12315 impl<'de> serde::Deserialize<'de> for GeneratedField {
12316 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12317 where
12318 D: serde::Deserializer<'de>,
12319 {
12320 struct GeneratedVisitor;
12321
12322 impl serde::de::Visitor<'_> for GeneratedVisitor {
12323 type Value = GeneratedField;
12324
12325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12326 write!(formatter, "expected one of: {:?}", &FIELDS)
12327 }
12328
12329 #[allow(unused_variables)]
12330 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12331 where
12332 E: serde::de::Error,
12333 {
12334 match value {
12335 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
12336 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
12337 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
12338 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
12339 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
12340 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12341 }
12342 }
12343 }
12344 deserializer.deserialize_identifier(GeneratedVisitor)
12345 }
12346 }
12347 struct GeneratedVisitor;
12348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12349 type Value = ProjectNode;
12350
12351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12352 formatter.write_str("struct stream_plan.ProjectNode")
12353 }
12354
12355 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
12356 where
12357 V: serde::de::MapAccess<'de>,
12358 {
12359 let mut select_list__ = None;
12360 let mut watermark_input_cols__ = None;
12361 let mut watermark_output_cols__ = None;
12362 let mut nondecreasing_exprs__ = None;
12363 let mut noop_update_hint__ = None;
12364 while let Some(k) = map_.next_key()? {
12365 match k {
12366 GeneratedField::SelectList => {
12367 if select_list__.is_some() {
12368 return Err(serde::de::Error::duplicate_field("selectList"));
12369 }
12370 select_list__ = Some(map_.next_value()?);
12371 }
12372 GeneratedField::WatermarkInputCols => {
12373 if watermark_input_cols__.is_some() {
12374 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
12375 }
12376 watermark_input_cols__ =
12377 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12378 .into_iter().map(|x| x.0).collect())
12379 ;
12380 }
12381 GeneratedField::WatermarkOutputCols => {
12382 if watermark_output_cols__.is_some() {
12383 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
12384 }
12385 watermark_output_cols__ =
12386 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12387 .into_iter().map(|x| x.0).collect())
12388 ;
12389 }
12390 GeneratedField::NondecreasingExprs => {
12391 if nondecreasing_exprs__.is_some() {
12392 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
12393 }
12394 nondecreasing_exprs__ =
12395 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12396 .into_iter().map(|x| x.0).collect())
12397 ;
12398 }
12399 GeneratedField::NoopUpdateHint => {
12400 if noop_update_hint__.is_some() {
12401 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
12402 }
12403 noop_update_hint__ = Some(map_.next_value()?);
12404 }
12405 }
12406 }
12407 Ok(ProjectNode {
12408 select_list: select_list__.unwrap_or_default(),
12409 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
12410 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
12411 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
12412 noop_update_hint: noop_update_hint__.unwrap_or_default(),
12413 })
12414 }
12415 }
12416 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
12417 }
12418}
12419impl serde::Serialize for ProjectSetNode {
12420 #[allow(deprecated)]
12421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12422 where
12423 S: serde::Serializer,
12424 {
12425 use serde::ser::SerializeStruct;
12426 let mut len = 0;
12427 if !self.select_list.is_empty() {
12428 len += 1;
12429 }
12430 if !self.watermark_input_cols.is_empty() {
12431 len += 1;
12432 }
12433 if !self.watermark_expr_indices.is_empty() {
12434 len += 1;
12435 }
12436 if !self.nondecreasing_exprs.is_empty() {
12437 len += 1;
12438 }
12439 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
12440 if !self.select_list.is_empty() {
12441 struct_ser.serialize_field("selectList", &self.select_list)?;
12442 }
12443 if !self.watermark_input_cols.is_empty() {
12444 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
12445 }
12446 if !self.watermark_expr_indices.is_empty() {
12447 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
12448 }
12449 if !self.nondecreasing_exprs.is_empty() {
12450 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
12451 }
12452 struct_ser.end()
12453 }
12454}
12455impl<'de> serde::Deserialize<'de> for ProjectSetNode {
12456 #[allow(deprecated)]
12457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12458 where
12459 D: serde::Deserializer<'de>,
12460 {
12461 const FIELDS: &[&str] = &[
12462 "select_list",
12463 "selectList",
12464 "watermark_input_cols",
12465 "watermarkInputCols",
12466 "watermark_expr_indices",
12467 "watermarkExprIndices",
12468 "nondecreasing_exprs",
12469 "nondecreasingExprs",
12470 ];
12471
12472 #[allow(clippy::enum_variant_names)]
12473 enum GeneratedField {
12474 SelectList,
12475 WatermarkInputCols,
12476 WatermarkExprIndices,
12477 NondecreasingExprs,
12478 }
12479 impl<'de> serde::Deserialize<'de> for GeneratedField {
12480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12481 where
12482 D: serde::Deserializer<'de>,
12483 {
12484 struct GeneratedVisitor;
12485
12486 impl serde::de::Visitor<'_> for GeneratedVisitor {
12487 type Value = GeneratedField;
12488
12489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12490 write!(formatter, "expected one of: {:?}", &FIELDS)
12491 }
12492
12493 #[allow(unused_variables)]
12494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12495 where
12496 E: serde::de::Error,
12497 {
12498 match value {
12499 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
12500 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
12501 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
12502 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
12503 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12504 }
12505 }
12506 }
12507 deserializer.deserialize_identifier(GeneratedVisitor)
12508 }
12509 }
12510 struct GeneratedVisitor;
12511 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12512 type Value = ProjectSetNode;
12513
12514 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12515 formatter.write_str("struct stream_plan.ProjectSetNode")
12516 }
12517
12518 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
12519 where
12520 V: serde::de::MapAccess<'de>,
12521 {
12522 let mut select_list__ = None;
12523 let mut watermark_input_cols__ = None;
12524 let mut watermark_expr_indices__ = None;
12525 let mut nondecreasing_exprs__ = None;
12526 while let Some(k) = map_.next_key()? {
12527 match k {
12528 GeneratedField::SelectList => {
12529 if select_list__.is_some() {
12530 return Err(serde::de::Error::duplicate_field("selectList"));
12531 }
12532 select_list__ = Some(map_.next_value()?);
12533 }
12534 GeneratedField::WatermarkInputCols => {
12535 if watermark_input_cols__.is_some() {
12536 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
12537 }
12538 watermark_input_cols__ =
12539 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12540 .into_iter().map(|x| x.0).collect())
12541 ;
12542 }
12543 GeneratedField::WatermarkExprIndices => {
12544 if watermark_expr_indices__.is_some() {
12545 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
12546 }
12547 watermark_expr_indices__ =
12548 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12549 .into_iter().map(|x| x.0).collect())
12550 ;
12551 }
12552 GeneratedField::NondecreasingExprs => {
12553 if nondecreasing_exprs__.is_some() {
12554 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
12555 }
12556 nondecreasing_exprs__ =
12557 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12558 .into_iter().map(|x| x.0).collect())
12559 ;
12560 }
12561 }
12562 }
12563 Ok(ProjectSetNode {
12564 select_list: select_list__.unwrap_or_default(),
12565 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
12566 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
12567 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
12568 })
12569 }
12570 }
12571 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
12572 }
12573}
12574impl serde::Serialize for RefreshStartMutation {
12575 #[allow(deprecated)]
12576 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12577 where
12578 S: serde::Serializer,
12579 {
12580 use serde::ser::SerializeStruct;
12581 let mut len = 0;
12582 if self.table_id != 0 {
12583 len += 1;
12584 }
12585 if self.associated_source_id != 0 {
12586 len += 1;
12587 }
12588 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
12589 if self.table_id != 0 {
12590 struct_ser.serialize_field("tableId", &self.table_id)?;
12591 }
12592 if self.associated_source_id != 0 {
12593 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
12594 }
12595 struct_ser.end()
12596 }
12597}
12598impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
12599 #[allow(deprecated)]
12600 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12601 where
12602 D: serde::Deserializer<'de>,
12603 {
12604 const FIELDS: &[&str] = &[
12605 "table_id",
12606 "tableId",
12607 "associated_source_id",
12608 "associatedSourceId",
12609 ];
12610
12611 #[allow(clippy::enum_variant_names)]
12612 enum GeneratedField {
12613 TableId,
12614 AssociatedSourceId,
12615 }
12616 impl<'de> serde::Deserialize<'de> for GeneratedField {
12617 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12618 where
12619 D: serde::Deserializer<'de>,
12620 {
12621 struct GeneratedVisitor;
12622
12623 impl serde::de::Visitor<'_> for GeneratedVisitor {
12624 type Value = GeneratedField;
12625
12626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12627 write!(formatter, "expected one of: {:?}", &FIELDS)
12628 }
12629
12630 #[allow(unused_variables)]
12631 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12632 where
12633 E: serde::de::Error,
12634 {
12635 match value {
12636 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12637 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
12638 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12639 }
12640 }
12641 }
12642 deserializer.deserialize_identifier(GeneratedVisitor)
12643 }
12644 }
12645 struct GeneratedVisitor;
12646 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12647 type Value = RefreshStartMutation;
12648
12649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12650 formatter.write_str("struct stream_plan.RefreshStartMutation")
12651 }
12652
12653 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
12654 where
12655 V: serde::de::MapAccess<'de>,
12656 {
12657 let mut table_id__ = None;
12658 let mut associated_source_id__ = None;
12659 while let Some(k) = map_.next_key()? {
12660 match k {
12661 GeneratedField::TableId => {
12662 if table_id__.is_some() {
12663 return Err(serde::de::Error::duplicate_field("tableId"));
12664 }
12665 table_id__ =
12666 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12667 ;
12668 }
12669 GeneratedField::AssociatedSourceId => {
12670 if associated_source_id__.is_some() {
12671 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
12672 }
12673 associated_source_id__ =
12674 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12675 ;
12676 }
12677 }
12678 }
12679 Ok(RefreshStartMutation {
12680 table_id: table_id__.unwrap_or_default(),
12681 associated_source_id: associated_source_id__.unwrap_or_default(),
12682 })
12683 }
12684 }
12685 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
12686 }
12687}
12688impl serde::Serialize for ResetSourceMutation {
12689 #[allow(deprecated)]
12690 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12691 where
12692 S: serde::Serializer,
12693 {
12694 use serde::ser::SerializeStruct;
12695 let mut len = 0;
12696 if self.source_id != 0 {
12697 len += 1;
12698 }
12699 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
12700 if self.source_id != 0 {
12701 struct_ser.serialize_field("sourceId", &self.source_id)?;
12702 }
12703 struct_ser.end()
12704 }
12705}
12706impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
12707 #[allow(deprecated)]
12708 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12709 where
12710 D: serde::Deserializer<'de>,
12711 {
12712 const FIELDS: &[&str] = &[
12713 "source_id",
12714 "sourceId",
12715 ];
12716
12717 #[allow(clippy::enum_variant_names)]
12718 enum GeneratedField {
12719 SourceId,
12720 }
12721 impl<'de> serde::Deserialize<'de> for GeneratedField {
12722 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12723 where
12724 D: serde::Deserializer<'de>,
12725 {
12726 struct GeneratedVisitor;
12727
12728 impl serde::de::Visitor<'_> for GeneratedVisitor {
12729 type Value = GeneratedField;
12730
12731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12732 write!(formatter, "expected one of: {:?}", &FIELDS)
12733 }
12734
12735 #[allow(unused_variables)]
12736 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12737 where
12738 E: serde::de::Error,
12739 {
12740 match value {
12741 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12742 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12743 }
12744 }
12745 }
12746 deserializer.deserialize_identifier(GeneratedVisitor)
12747 }
12748 }
12749 struct GeneratedVisitor;
12750 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12751 type Value = ResetSourceMutation;
12752
12753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12754 formatter.write_str("struct stream_plan.ResetSourceMutation")
12755 }
12756
12757 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
12758 where
12759 V: serde::de::MapAccess<'de>,
12760 {
12761 let mut source_id__ = None;
12762 while let Some(k) = map_.next_key()? {
12763 match k {
12764 GeneratedField::SourceId => {
12765 if source_id__.is_some() {
12766 return Err(serde::de::Error::duplicate_field("sourceId"));
12767 }
12768 source_id__ =
12769 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12770 ;
12771 }
12772 }
12773 }
12774 Ok(ResetSourceMutation {
12775 source_id: source_id__.unwrap_or_default(),
12776 })
12777 }
12778 }
12779 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
12780 }
12781}
12782impl serde::Serialize for ResumeMutation {
12783 #[allow(deprecated)]
12784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12785 where
12786 S: serde::Serializer,
12787 {
12788 use serde::ser::SerializeStruct;
12789 let len = 0;
12790 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
12791 struct_ser.end()
12792 }
12793}
12794impl<'de> serde::Deserialize<'de> for ResumeMutation {
12795 #[allow(deprecated)]
12796 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12797 where
12798 D: serde::Deserializer<'de>,
12799 {
12800 const FIELDS: &[&str] = &[
12801 ];
12802
12803 #[allow(clippy::enum_variant_names)]
12804 enum GeneratedField {
12805 }
12806 impl<'de> serde::Deserialize<'de> for GeneratedField {
12807 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12808 where
12809 D: serde::Deserializer<'de>,
12810 {
12811 struct GeneratedVisitor;
12812
12813 impl serde::de::Visitor<'_> for GeneratedVisitor {
12814 type Value = GeneratedField;
12815
12816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12817 write!(formatter, "expected one of: {:?}", &FIELDS)
12818 }
12819
12820 #[allow(unused_variables)]
12821 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12822 where
12823 E: serde::de::Error,
12824 {
12825 Err(serde::de::Error::unknown_field(value, FIELDS))
12826 }
12827 }
12828 deserializer.deserialize_identifier(GeneratedVisitor)
12829 }
12830 }
12831 struct GeneratedVisitor;
12832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12833 type Value = ResumeMutation;
12834
12835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12836 formatter.write_str("struct stream_plan.ResumeMutation")
12837 }
12838
12839 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
12840 where
12841 V: serde::de::MapAccess<'de>,
12842 {
12843 while map_.next_key::<GeneratedField>()?.is_some() {
12844 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12845 }
12846 Ok(ResumeMutation {
12847 })
12848 }
12849 }
12850 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
12851 }
12852}
12853impl serde::Serialize for RowIdGenNode {
12854 #[allow(deprecated)]
12855 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12856 where
12857 S: serde::Serializer,
12858 {
12859 use serde::ser::SerializeStruct;
12860 let mut len = 0;
12861 if self.row_id_index != 0 {
12862 len += 1;
12863 }
12864 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
12865 if self.row_id_index != 0 {
12866 #[allow(clippy::needless_borrow)]
12867 #[allow(clippy::needless_borrows_for_generic_args)]
12868 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
12869 }
12870 struct_ser.end()
12871 }
12872}
12873impl<'de> serde::Deserialize<'de> for RowIdGenNode {
12874 #[allow(deprecated)]
12875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12876 where
12877 D: serde::Deserializer<'de>,
12878 {
12879 const FIELDS: &[&str] = &[
12880 "row_id_index",
12881 "rowIdIndex",
12882 ];
12883
12884 #[allow(clippy::enum_variant_names)]
12885 enum GeneratedField {
12886 RowIdIndex,
12887 }
12888 impl<'de> serde::Deserialize<'de> for GeneratedField {
12889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12890 where
12891 D: serde::Deserializer<'de>,
12892 {
12893 struct GeneratedVisitor;
12894
12895 impl serde::de::Visitor<'_> for GeneratedVisitor {
12896 type Value = GeneratedField;
12897
12898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12899 write!(formatter, "expected one of: {:?}", &FIELDS)
12900 }
12901
12902 #[allow(unused_variables)]
12903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12904 where
12905 E: serde::de::Error,
12906 {
12907 match value {
12908 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12910 }
12911 }
12912 }
12913 deserializer.deserialize_identifier(GeneratedVisitor)
12914 }
12915 }
12916 struct GeneratedVisitor;
12917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12918 type Value = RowIdGenNode;
12919
12920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12921 formatter.write_str("struct stream_plan.RowIdGenNode")
12922 }
12923
12924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
12925 where
12926 V: serde::de::MapAccess<'de>,
12927 {
12928 let mut row_id_index__ = None;
12929 while let Some(k) = map_.next_key()? {
12930 match k {
12931 GeneratedField::RowIdIndex => {
12932 if row_id_index__.is_some() {
12933 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12934 }
12935 row_id_index__ =
12936 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12937 ;
12938 }
12939 }
12940 }
12941 Ok(RowIdGenNode {
12942 row_id_index: row_id_index__.unwrap_or_default(),
12943 })
12944 }
12945 }
12946 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
12947 }
12948}
12949impl serde::Serialize for RowMergeNode {
12950 #[allow(deprecated)]
12951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12952 where
12953 S: serde::Serializer,
12954 {
12955 use serde::ser::SerializeStruct;
12956 let mut len = 0;
12957 if self.lhs_mapping.is_some() {
12958 len += 1;
12959 }
12960 if self.rhs_mapping.is_some() {
12961 len += 1;
12962 }
12963 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
12964 if let Some(v) = self.lhs_mapping.as_ref() {
12965 struct_ser.serialize_field("lhsMapping", v)?;
12966 }
12967 if let Some(v) = self.rhs_mapping.as_ref() {
12968 struct_ser.serialize_field("rhsMapping", v)?;
12969 }
12970 struct_ser.end()
12971 }
12972}
12973impl<'de> serde::Deserialize<'de> for RowMergeNode {
12974 #[allow(deprecated)]
12975 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12976 where
12977 D: serde::Deserializer<'de>,
12978 {
12979 const FIELDS: &[&str] = &[
12980 "lhs_mapping",
12981 "lhsMapping",
12982 "rhs_mapping",
12983 "rhsMapping",
12984 ];
12985
12986 #[allow(clippy::enum_variant_names)]
12987 enum GeneratedField {
12988 LhsMapping,
12989 RhsMapping,
12990 }
12991 impl<'de> serde::Deserialize<'de> for GeneratedField {
12992 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12993 where
12994 D: serde::Deserializer<'de>,
12995 {
12996 struct GeneratedVisitor;
12997
12998 impl serde::de::Visitor<'_> for GeneratedVisitor {
12999 type Value = GeneratedField;
13000
13001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13002 write!(formatter, "expected one of: {:?}", &FIELDS)
13003 }
13004
13005 #[allow(unused_variables)]
13006 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13007 where
13008 E: serde::de::Error,
13009 {
13010 match value {
13011 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
13012 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
13013 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13014 }
13015 }
13016 }
13017 deserializer.deserialize_identifier(GeneratedVisitor)
13018 }
13019 }
13020 struct GeneratedVisitor;
13021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13022 type Value = RowMergeNode;
13023
13024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13025 formatter.write_str("struct stream_plan.RowMergeNode")
13026 }
13027
13028 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
13029 where
13030 V: serde::de::MapAccess<'de>,
13031 {
13032 let mut lhs_mapping__ = None;
13033 let mut rhs_mapping__ = None;
13034 while let Some(k) = map_.next_key()? {
13035 match k {
13036 GeneratedField::LhsMapping => {
13037 if lhs_mapping__.is_some() {
13038 return Err(serde::de::Error::duplicate_field("lhsMapping"));
13039 }
13040 lhs_mapping__ = map_.next_value()?;
13041 }
13042 GeneratedField::RhsMapping => {
13043 if rhs_mapping__.is_some() {
13044 return Err(serde::de::Error::duplicate_field("rhsMapping"));
13045 }
13046 rhs_mapping__ = map_.next_value()?;
13047 }
13048 }
13049 }
13050 Ok(RowMergeNode {
13051 lhs_mapping: lhs_mapping__,
13052 rhs_mapping: rhs_mapping__,
13053 })
13054 }
13055 }
13056 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
13057 }
13058}
13059impl serde::Serialize for SimpleAggNode {
13060 #[allow(deprecated)]
13061 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13062 where
13063 S: serde::Serializer,
13064 {
13065 use serde::ser::SerializeStruct;
13066 let mut len = 0;
13067 if !self.agg_calls.is_empty() {
13068 len += 1;
13069 }
13070 if !self.agg_call_states.is_empty() {
13071 len += 1;
13072 }
13073 if self.intermediate_state_table.is_some() {
13074 len += 1;
13075 }
13076 if self.is_append_only {
13077 len += 1;
13078 }
13079 if !self.distinct_dedup_tables.is_empty() {
13080 len += 1;
13081 }
13082 if self.row_count_index != 0 {
13083 len += 1;
13084 }
13085 if self.version != 0 {
13086 len += 1;
13087 }
13088 if self.must_output_per_barrier {
13089 len += 1;
13090 }
13091 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
13092 if !self.agg_calls.is_empty() {
13093 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
13094 }
13095 if !self.agg_call_states.is_empty() {
13096 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
13097 }
13098 if let Some(v) = self.intermediate_state_table.as_ref() {
13099 struct_ser.serialize_field("intermediateStateTable", v)?;
13100 }
13101 if self.is_append_only {
13102 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
13103 }
13104 if !self.distinct_dedup_tables.is_empty() {
13105 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
13106 }
13107 if self.row_count_index != 0 {
13108 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
13109 }
13110 if self.version != 0 {
13111 let v = AggNodeVersion::try_from(self.version)
13112 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
13113 struct_ser.serialize_field("version", &v)?;
13114 }
13115 if self.must_output_per_barrier {
13116 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
13117 }
13118 struct_ser.end()
13119 }
13120}
13121impl<'de> serde::Deserialize<'de> for SimpleAggNode {
13122 #[allow(deprecated)]
13123 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13124 where
13125 D: serde::Deserializer<'de>,
13126 {
13127 const FIELDS: &[&str] = &[
13128 "agg_calls",
13129 "aggCalls",
13130 "agg_call_states",
13131 "aggCallStates",
13132 "intermediate_state_table",
13133 "intermediateStateTable",
13134 "is_append_only",
13135 "isAppendOnly",
13136 "distinct_dedup_tables",
13137 "distinctDedupTables",
13138 "row_count_index",
13139 "rowCountIndex",
13140 "version",
13141 "must_output_per_barrier",
13142 "mustOutputPerBarrier",
13143 ];
13144
13145 #[allow(clippy::enum_variant_names)]
13146 enum GeneratedField {
13147 AggCalls,
13148 AggCallStates,
13149 IntermediateStateTable,
13150 IsAppendOnly,
13151 DistinctDedupTables,
13152 RowCountIndex,
13153 Version,
13154 MustOutputPerBarrier,
13155 }
13156 impl<'de> serde::Deserialize<'de> for GeneratedField {
13157 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13158 where
13159 D: serde::Deserializer<'de>,
13160 {
13161 struct GeneratedVisitor;
13162
13163 impl serde::de::Visitor<'_> for GeneratedVisitor {
13164 type Value = GeneratedField;
13165
13166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13167 write!(formatter, "expected one of: {:?}", &FIELDS)
13168 }
13169
13170 #[allow(unused_variables)]
13171 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13172 where
13173 E: serde::de::Error,
13174 {
13175 match value {
13176 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
13177 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
13178 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
13179 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
13180 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
13181 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
13182 "version" => Ok(GeneratedField::Version),
13183 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
13184 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13185 }
13186 }
13187 }
13188 deserializer.deserialize_identifier(GeneratedVisitor)
13189 }
13190 }
13191 struct GeneratedVisitor;
13192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13193 type Value = SimpleAggNode;
13194
13195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13196 formatter.write_str("struct stream_plan.SimpleAggNode")
13197 }
13198
13199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
13200 where
13201 V: serde::de::MapAccess<'de>,
13202 {
13203 let mut agg_calls__ = None;
13204 let mut agg_call_states__ = None;
13205 let mut intermediate_state_table__ = None;
13206 let mut is_append_only__ = None;
13207 let mut distinct_dedup_tables__ = None;
13208 let mut row_count_index__ = None;
13209 let mut version__ = None;
13210 let mut must_output_per_barrier__ = None;
13211 while let Some(k) = map_.next_key()? {
13212 match k {
13213 GeneratedField::AggCalls => {
13214 if agg_calls__.is_some() {
13215 return Err(serde::de::Error::duplicate_field("aggCalls"));
13216 }
13217 agg_calls__ = Some(map_.next_value()?);
13218 }
13219 GeneratedField::AggCallStates => {
13220 if agg_call_states__.is_some() {
13221 return Err(serde::de::Error::duplicate_field("aggCallStates"));
13222 }
13223 agg_call_states__ = Some(map_.next_value()?);
13224 }
13225 GeneratedField::IntermediateStateTable => {
13226 if intermediate_state_table__.is_some() {
13227 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
13228 }
13229 intermediate_state_table__ = map_.next_value()?;
13230 }
13231 GeneratedField::IsAppendOnly => {
13232 if is_append_only__.is_some() {
13233 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
13234 }
13235 is_append_only__ = Some(map_.next_value()?);
13236 }
13237 GeneratedField::DistinctDedupTables => {
13238 if distinct_dedup_tables__.is_some() {
13239 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
13240 }
13241 distinct_dedup_tables__ = Some(
13242 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13243 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
13244 );
13245 }
13246 GeneratedField::RowCountIndex => {
13247 if row_count_index__.is_some() {
13248 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
13249 }
13250 row_count_index__ =
13251 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13252 ;
13253 }
13254 GeneratedField::Version => {
13255 if version__.is_some() {
13256 return Err(serde::de::Error::duplicate_field("version"));
13257 }
13258 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
13259 }
13260 GeneratedField::MustOutputPerBarrier => {
13261 if must_output_per_barrier__.is_some() {
13262 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
13263 }
13264 must_output_per_barrier__ = Some(map_.next_value()?);
13265 }
13266 }
13267 }
13268 Ok(SimpleAggNode {
13269 agg_calls: agg_calls__.unwrap_or_default(),
13270 agg_call_states: agg_call_states__.unwrap_or_default(),
13271 intermediate_state_table: intermediate_state_table__,
13272 is_append_only: is_append_only__.unwrap_or_default(),
13273 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
13274 row_count_index: row_count_index__.unwrap_or_default(),
13275 version: version__.unwrap_or_default(),
13276 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
13277 })
13278 }
13279 }
13280 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
13281 }
13282}
13283impl serde::Serialize for SinkAddColumnsOp {
13284 #[allow(deprecated)]
13285 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13286 where
13287 S: serde::Serializer,
13288 {
13289 use serde::ser::SerializeStruct;
13290 let mut len = 0;
13291 if !self.fields.is_empty() {
13292 len += 1;
13293 }
13294 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
13295 if !self.fields.is_empty() {
13296 struct_ser.serialize_field("fields", &self.fields)?;
13297 }
13298 struct_ser.end()
13299 }
13300}
13301impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
13302 #[allow(deprecated)]
13303 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13304 where
13305 D: serde::Deserializer<'de>,
13306 {
13307 const FIELDS: &[&str] = &[
13308 "fields",
13309 ];
13310
13311 #[allow(clippy::enum_variant_names)]
13312 enum GeneratedField {
13313 Fields,
13314 }
13315 impl<'de> serde::Deserialize<'de> for GeneratedField {
13316 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13317 where
13318 D: serde::Deserializer<'de>,
13319 {
13320 struct GeneratedVisitor;
13321
13322 impl serde::de::Visitor<'_> for GeneratedVisitor {
13323 type Value = GeneratedField;
13324
13325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13326 write!(formatter, "expected one of: {:?}", &FIELDS)
13327 }
13328
13329 #[allow(unused_variables)]
13330 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13331 where
13332 E: serde::de::Error,
13333 {
13334 match value {
13335 "fields" => Ok(GeneratedField::Fields),
13336 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13337 }
13338 }
13339 }
13340 deserializer.deserialize_identifier(GeneratedVisitor)
13341 }
13342 }
13343 struct GeneratedVisitor;
13344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13345 type Value = SinkAddColumnsOp;
13346
13347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13348 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
13349 }
13350
13351 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
13352 where
13353 V: serde::de::MapAccess<'de>,
13354 {
13355 let mut fields__ = None;
13356 while let Some(k) = map_.next_key()? {
13357 match k {
13358 GeneratedField::Fields => {
13359 if fields__.is_some() {
13360 return Err(serde::de::Error::duplicate_field("fields"));
13361 }
13362 fields__ = Some(map_.next_value()?);
13363 }
13364 }
13365 }
13366 Ok(SinkAddColumnsOp {
13367 fields: fields__.unwrap_or_default(),
13368 })
13369 }
13370 }
13371 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
13372 }
13373}
13374impl serde::Serialize for SinkDesc {
13375 #[allow(deprecated)]
13376 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13377 where
13378 S: serde::Serializer,
13379 {
13380 use serde::ser::SerializeStruct;
13381 let mut len = 0;
13382 if self.id != 0 {
13383 len += 1;
13384 }
13385 if !self.name.is_empty() {
13386 len += 1;
13387 }
13388 if !self.definition.is_empty() {
13389 len += 1;
13390 }
13391 if !self.plan_pk.is_empty() {
13392 len += 1;
13393 }
13394 if !self.downstream_pk.is_empty() {
13395 len += 1;
13396 }
13397 if !self.distribution_key.is_empty() {
13398 len += 1;
13399 }
13400 if !self.properties.is_empty() {
13401 len += 1;
13402 }
13403 if self.sink_type != 0 {
13404 len += 1;
13405 }
13406 if !self.column_catalogs.is_empty() {
13407 len += 1;
13408 }
13409 if !self.db_name.is_empty() {
13410 len += 1;
13411 }
13412 if !self.sink_from_name.is_empty() {
13413 len += 1;
13414 }
13415 if self.format_desc.is_some() {
13416 len += 1;
13417 }
13418 if self.target_table.is_some() {
13419 len += 1;
13420 }
13421 if self.extra_partition_col_idx.is_some() {
13422 len += 1;
13423 }
13424 if !self.secret_refs.is_empty() {
13425 len += 1;
13426 }
13427 if self.raw_ignore_delete {
13428 len += 1;
13429 }
13430 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
13431 if self.id != 0 {
13432 struct_ser.serialize_field("id", &self.id)?;
13433 }
13434 if !self.name.is_empty() {
13435 struct_ser.serialize_field("name", &self.name)?;
13436 }
13437 if !self.definition.is_empty() {
13438 struct_ser.serialize_field("definition", &self.definition)?;
13439 }
13440 if !self.plan_pk.is_empty() {
13441 struct_ser.serialize_field("planPk", &self.plan_pk)?;
13442 }
13443 if !self.downstream_pk.is_empty() {
13444 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
13445 }
13446 if !self.distribution_key.is_empty() {
13447 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
13448 }
13449 if !self.properties.is_empty() {
13450 struct_ser.serialize_field("properties", &self.properties)?;
13451 }
13452 if self.sink_type != 0 {
13453 let v = super::catalog::SinkType::try_from(self.sink_type)
13454 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
13455 struct_ser.serialize_field("sinkType", &v)?;
13456 }
13457 if !self.column_catalogs.is_empty() {
13458 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
13459 }
13460 if !self.db_name.is_empty() {
13461 struct_ser.serialize_field("dbName", &self.db_name)?;
13462 }
13463 if !self.sink_from_name.is_empty() {
13464 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
13465 }
13466 if let Some(v) = self.format_desc.as_ref() {
13467 struct_ser.serialize_field("formatDesc", v)?;
13468 }
13469 if let Some(v) = self.target_table.as_ref() {
13470 struct_ser.serialize_field("targetTable", v)?;
13471 }
13472 if let Some(v) = self.extra_partition_col_idx.as_ref() {
13473 #[allow(clippy::needless_borrow)]
13474 #[allow(clippy::needless_borrows_for_generic_args)]
13475 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
13476 }
13477 if !self.secret_refs.is_empty() {
13478 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13479 }
13480 if self.raw_ignore_delete {
13481 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
13482 }
13483 struct_ser.end()
13484 }
13485}
13486impl<'de> serde::Deserialize<'de> for SinkDesc {
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 "id",
13494 "name",
13495 "definition",
13496 "plan_pk",
13497 "planPk",
13498 "downstream_pk",
13499 "downstreamPk",
13500 "distribution_key",
13501 "distributionKey",
13502 "properties",
13503 "sink_type",
13504 "sinkType",
13505 "column_catalogs",
13506 "columnCatalogs",
13507 "db_name",
13508 "dbName",
13509 "sink_from_name",
13510 "sinkFromName",
13511 "format_desc",
13512 "formatDesc",
13513 "target_table",
13514 "targetTable",
13515 "extra_partition_col_idx",
13516 "extraPartitionColIdx",
13517 "secret_refs",
13518 "secretRefs",
13519 "raw_ignore_delete",
13520 "rawIgnoreDelete",
13521 ];
13522
13523 #[allow(clippy::enum_variant_names)]
13524 enum GeneratedField {
13525 Id,
13526 Name,
13527 Definition,
13528 PlanPk,
13529 DownstreamPk,
13530 DistributionKey,
13531 Properties,
13532 SinkType,
13533 ColumnCatalogs,
13534 DbName,
13535 SinkFromName,
13536 FormatDesc,
13537 TargetTable,
13538 ExtraPartitionColIdx,
13539 SecretRefs,
13540 RawIgnoreDelete,
13541 }
13542 impl<'de> serde::Deserialize<'de> for GeneratedField {
13543 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13544 where
13545 D: serde::Deserializer<'de>,
13546 {
13547 struct GeneratedVisitor;
13548
13549 impl serde::de::Visitor<'_> for GeneratedVisitor {
13550 type Value = GeneratedField;
13551
13552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13553 write!(formatter, "expected one of: {:?}", &FIELDS)
13554 }
13555
13556 #[allow(unused_variables)]
13557 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13558 where
13559 E: serde::de::Error,
13560 {
13561 match value {
13562 "id" => Ok(GeneratedField::Id),
13563 "name" => Ok(GeneratedField::Name),
13564 "definition" => Ok(GeneratedField::Definition),
13565 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
13566 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
13567 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
13568 "properties" => Ok(GeneratedField::Properties),
13569 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
13570 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
13571 "dbName" | "db_name" => Ok(GeneratedField::DbName),
13572 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
13573 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
13574 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
13575 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
13576 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13577 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
13578 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13579 }
13580 }
13581 }
13582 deserializer.deserialize_identifier(GeneratedVisitor)
13583 }
13584 }
13585 struct GeneratedVisitor;
13586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13587 type Value = SinkDesc;
13588
13589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13590 formatter.write_str("struct stream_plan.SinkDesc")
13591 }
13592
13593 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
13594 where
13595 V: serde::de::MapAccess<'de>,
13596 {
13597 let mut id__ = None;
13598 let mut name__ = None;
13599 let mut definition__ = None;
13600 let mut plan_pk__ = None;
13601 let mut downstream_pk__ = None;
13602 let mut distribution_key__ = None;
13603 let mut properties__ = None;
13604 let mut sink_type__ = None;
13605 let mut column_catalogs__ = None;
13606 let mut db_name__ = None;
13607 let mut sink_from_name__ = None;
13608 let mut format_desc__ = None;
13609 let mut target_table__ = None;
13610 let mut extra_partition_col_idx__ = None;
13611 let mut secret_refs__ = None;
13612 let mut raw_ignore_delete__ = None;
13613 while let Some(k) = map_.next_key()? {
13614 match k {
13615 GeneratedField::Id => {
13616 if id__.is_some() {
13617 return Err(serde::de::Error::duplicate_field("id"));
13618 }
13619 id__ =
13620 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13621 ;
13622 }
13623 GeneratedField::Name => {
13624 if name__.is_some() {
13625 return Err(serde::de::Error::duplicate_field("name"));
13626 }
13627 name__ = Some(map_.next_value()?);
13628 }
13629 GeneratedField::Definition => {
13630 if definition__.is_some() {
13631 return Err(serde::de::Error::duplicate_field("definition"));
13632 }
13633 definition__ = Some(map_.next_value()?);
13634 }
13635 GeneratedField::PlanPk => {
13636 if plan_pk__.is_some() {
13637 return Err(serde::de::Error::duplicate_field("planPk"));
13638 }
13639 plan_pk__ = Some(map_.next_value()?);
13640 }
13641 GeneratedField::DownstreamPk => {
13642 if downstream_pk__.is_some() {
13643 return Err(serde::de::Error::duplicate_field("downstreamPk"));
13644 }
13645 downstream_pk__ =
13646 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13647 .into_iter().map(|x| x.0).collect())
13648 ;
13649 }
13650 GeneratedField::DistributionKey => {
13651 if distribution_key__.is_some() {
13652 return Err(serde::de::Error::duplicate_field("distributionKey"));
13653 }
13654 distribution_key__ =
13655 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13656 .into_iter().map(|x| x.0).collect())
13657 ;
13658 }
13659 GeneratedField::Properties => {
13660 if properties__.is_some() {
13661 return Err(serde::de::Error::duplicate_field("properties"));
13662 }
13663 properties__ = Some(
13664 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13665 );
13666 }
13667 GeneratedField::SinkType => {
13668 if sink_type__.is_some() {
13669 return Err(serde::de::Error::duplicate_field("sinkType"));
13670 }
13671 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
13672 }
13673 GeneratedField::ColumnCatalogs => {
13674 if column_catalogs__.is_some() {
13675 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
13676 }
13677 column_catalogs__ = Some(map_.next_value()?);
13678 }
13679 GeneratedField::DbName => {
13680 if db_name__.is_some() {
13681 return Err(serde::de::Error::duplicate_field("dbName"));
13682 }
13683 db_name__ = Some(map_.next_value()?);
13684 }
13685 GeneratedField::SinkFromName => {
13686 if sink_from_name__.is_some() {
13687 return Err(serde::de::Error::duplicate_field("sinkFromName"));
13688 }
13689 sink_from_name__ = Some(map_.next_value()?);
13690 }
13691 GeneratedField::FormatDesc => {
13692 if format_desc__.is_some() {
13693 return Err(serde::de::Error::duplicate_field("formatDesc"));
13694 }
13695 format_desc__ = map_.next_value()?;
13696 }
13697 GeneratedField::TargetTable => {
13698 if target_table__.is_some() {
13699 return Err(serde::de::Error::duplicate_field("targetTable"));
13700 }
13701 target_table__ =
13702 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13703 ;
13704 }
13705 GeneratedField::ExtraPartitionColIdx => {
13706 if extra_partition_col_idx__.is_some() {
13707 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
13708 }
13709 extra_partition_col_idx__ =
13710 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13711 ;
13712 }
13713 GeneratedField::SecretRefs => {
13714 if secret_refs__.is_some() {
13715 return Err(serde::de::Error::duplicate_field("secretRefs"));
13716 }
13717 secret_refs__ = Some(
13718 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13719 );
13720 }
13721 GeneratedField::RawIgnoreDelete => {
13722 if raw_ignore_delete__.is_some() {
13723 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
13724 }
13725 raw_ignore_delete__ = Some(map_.next_value()?);
13726 }
13727 }
13728 }
13729 Ok(SinkDesc {
13730 id: id__.unwrap_or_default(),
13731 name: name__.unwrap_or_default(),
13732 definition: definition__.unwrap_or_default(),
13733 plan_pk: plan_pk__.unwrap_or_default(),
13734 downstream_pk: downstream_pk__.unwrap_or_default(),
13735 distribution_key: distribution_key__.unwrap_or_default(),
13736 properties: properties__.unwrap_or_default(),
13737 sink_type: sink_type__.unwrap_or_default(),
13738 column_catalogs: column_catalogs__.unwrap_or_default(),
13739 db_name: db_name__.unwrap_or_default(),
13740 sink_from_name: sink_from_name__.unwrap_or_default(),
13741 format_desc: format_desc__,
13742 target_table: target_table__,
13743 extra_partition_col_idx: extra_partition_col_idx__,
13744 secret_refs: secret_refs__.unwrap_or_default(),
13745 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
13746 })
13747 }
13748 }
13749 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
13750 }
13751}
13752impl serde::Serialize for SinkDropColumnsOp {
13753 #[allow(deprecated)]
13754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13755 where
13756 S: serde::Serializer,
13757 {
13758 use serde::ser::SerializeStruct;
13759 let mut len = 0;
13760 if !self.column_names.is_empty() {
13761 len += 1;
13762 }
13763 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
13764 if !self.column_names.is_empty() {
13765 struct_ser.serialize_field("columnNames", &self.column_names)?;
13766 }
13767 struct_ser.end()
13768 }
13769}
13770impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
13771 #[allow(deprecated)]
13772 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13773 where
13774 D: serde::Deserializer<'de>,
13775 {
13776 const FIELDS: &[&str] = &[
13777 "column_names",
13778 "columnNames",
13779 ];
13780
13781 #[allow(clippy::enum_variant_names)]
13782 enum GeneratedField {
13783 ColumnNames,
13784 }
13785 impl<'de> serde::Deserialize<'de> for GeneratedField {
13786 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13787 where
13788 D: serde::Deserializer<'de>,
13789 {
13790 struct GeneratedVisitor;
13791
13792 impl serde::de::Visitor<'_> for GeneratedVisitor {
13793 type Value = GeneratedField;
13794
13795 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13796 write!(formatter, "expected one of: {:?}", &FIELDS)
13797 }
13798
13799 #[allow(unused_variables)]
13800 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13801 where
13802 E: serde::de::Error,
13803 {
13804 match value {
13805 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
13806 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13807 }
13808 }
13809 }
13810 deserializer.deserialize_identifier(GeneratedVisitor)
13811 }
13812 }
13813 struct GeneratedVisitor;
13814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13815 type Value = SinkDropColumnsOp;
13816
13817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13818 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
13819 }
13820
13821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
13822 where
13823 V: serde::de::MapAccess<'de>,
13824 {
13825 let mut column_names__ = None;
13826 while let Some(k) = map_.next_key()? {
13827 match k {
13828 GeneratedField::ColumnNames => {
13829 if column_names__.is_some() {
13830 return Err(serde::de::Error::duplicate_field("columnNames"));
13831 }
13832 column_names__ = Some(map_.next_value()?);
13833 }
13834 }
13835 }
13836 Ok(SinkDropColumnsOp {
13837 column_names: column_names__.unwrap_or_default(),
13838 })
13839 }
13840 }
13841 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
13842 }
13843}
13844impl serde::Serialize for SinkLogStoreType {
13845 #[allow(deprecated)]
13846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13847 where
13848 S: serde::Serializer,
13849 {
13850 let variant = match self {
13851 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
13852 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
13853 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
13854 };
13855 serializer.serialize_str(variant)
13856 }
13857}
13858impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
13859 #[allow(deprecated)]
13860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13861 where
13862 D: serde::Deserializer<'de>,
13863 {
13864 const FIELDS: &[&str] = &[
13865 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
13866 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
13867 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
13868 ];
13869
13870 struct GeneratedVisitor;
13871
13872 impl serde::de::Visitor<'_> for GeneratedVisitor {
13873 type Value = SinkLogStoreType;
13874
13875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13876 write!(formatter, "expected one of: {:?}", &FIELDS)
13877 }
13878
13879 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13880 where
13881 E: serde::de::Error,
13882 {
13883 i32::try_from(v)
13884 .ok()
13885 .and_then(|x| x.try_into().ok())
13886 .ok_or_else(|| {
13887 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13888 })
13889 }
13890
13891 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13892 where
13893 E: serde::de::Error,
13894 {
13895 i32::try_from(v)
13896 .ok()
13897 .and_then(|x| x.try_into().ok())
13898 .ok_or_else(|| {
13899 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13900 })
13901 }
13902
13903 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13904 where
13905 E: serde::de::Error,
13906 {
13907 match value {
13908 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
13909 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
13910 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
13911 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13912 }
13913 }
13914 }
13915 deserializer.deserialize_any(GeneratedVisitor)
13916 }
13917}
13918impl serde::Serialize for SinkNode {
13919 #[allow(deprecated)]
13920 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13921 where
13922 S: serde::Serializer,
13923 {
13924 use serde::ser::SerializeStruct;
13925 let mut len = 0;
13926 if self.sink_desc.is_some() {
13927 len += 1;
13928 }
13929 if self.table.is_some() {
13930 len += 1;
13931 }
13932 if self.log_store_type != 0 {
13933 len += 1;
13934 }
13935 if self.rate_limit.is_some() {
13936 len += 1;
13937 }
13938 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
13939 if let Some(v) = self.sink_desc.as_ref() {
13940 struct_ser.serialize_field("sinkDesc", v)?;
13941 }
13942 if let Some(v) = self.table.as_ref() {
13943 struct_ser.serialize_field("table", v)?;
13944 }
13945 if self.log_store_type != 0 {
13946 let v = SinkLogStoreType::try_from(self.log_store_type)
13947 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
13948 struct_ser.serialize_field("logStoreType", &v)?;
13949 }
13950 if let Some(v) = self.rate_limit.as_ref() {
13951 struct_ser.serialize_field("rateLimit", v)?;
13952 }
13953 struct_ser.end()
13954 }
13955}
13956impl<'de> serde::Deserialize<'de> for SinkNode {
13957 #[allow(deprecated)]
13958 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13959 where
13960 D: serde::Deserializer<'de>,
13961 {
13962 const FIELDS: &[&str] = &[
13963 "sink_desc",
13964 "sinkDesc",
13965 "table",
13966 "log_store_type",
13967 "logStoreType",
13968 "rate_limit",
13969 "rateLimit",
13970 ];
13971
13972 #[allow(clippy::enum_variant_names)]
13973 enum GeneratedField {
13974 SinkDesc,
13975 Table,
13976 LogStoreType,
13977 RateLimit,
13978 }
13979 impl<'de> serde::Deserialize<'de> for GeneratedField {
13980 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13981 where
13982 D: serde::Deserializer<'de>,
13983 {
13984 struct GeneratedVisitor;
13985
13986 impl serde::de::Visitor<'_> for GeneratedVisitor {
13987 type Value = GeneratedField;
13988
13989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13990 write!(formatter, "expected one of: {:?}", &FIELDS)
13991 }
13992
13993 #[allow(unused_variables)]
13994 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13995 where
13996 E: serde::de::Error,
13997 {
13998 match value {
13999 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
14000 "table" => Ok(GeneratedField::Table),
14001 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
14002 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14003 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14004 }
14005 }
14006 }
14007 deserializer.deserialize_identifier(GeneratedVisitor)
14008 }
14009 }
14010 struct GeneratedVisitor;
14011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14012 type Value = SinkNode;
14013
14014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14015 formatter.write_str("struct stream_plan.SinkNode")
14016 }
14017
14018 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
14019 where
14020 V: serde::de::MapAccess<'de>,
14021 {
14022 let mut sink_desc__ = None;
14023 let mut table__ = None;
14024 let mut log_store_type__ = None;
14025 let mut rate_limit__ = None;
14026 while let Some(k) = map_.next_key()? {
14027 match k {
14028 GeneratedField::SinkDesc => {
14029 if sink_desc__.is_some() {
14030 return Err(serde::de::Error::duplicate_field("sinkDesc"));
14031 }
14032 sink_desc__ = map_.next_value()?;
14033 }
14034 GeneratedField::Table => {
14035 if table__.is_some() {
14036 return Err(serde::de::Error::duplicate_field("table"));
14037 }
14038 table__ = map_.next_value()?;
14039 }
14040 GeneratedField::LogStoreType => {
14041 if log_store_type__.is_some() {
14042 return Err(serde::de::Error::duplicate_field("logStoreType"));
14043 }
14044 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
14045 }
14046 GeneratedField::RateLimit => {
14047 if rate_limit__.is_some() {
14048 return Err(serde::de::Error::duplicate_field("rateLimit"));
14049 }
14050 rate_limit__ =
14051 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14052 ;
14053 }
14054 }
14055 }
14056 Ok(SinkNode {
14057 sink_desc: sink_desc__,
14058 table: table__,
14059 log_store_type: log_store_type__.unwrap_or_default(),
14060 rate_limit: rate_limit__,
14061 })
14062 }
14063 }
14064 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
14065 }
14066}
14067impl serde::Serialize for SinkSchemaChange {
14068 #[allow(deprecated)]
14069 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14070 where
14071 S: serde::Serializer,
14072 {
14073 use serde::ser::SerializeStruct;
14074 let mut len = 0;
14075 if !self.original_schema.is_empty() {
14076 len += 1;
14077 }
14078 if self.op.is_some() {
14079 len += 1;
14080 }
14081 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
14082 if !self.original_schema.is_empty() {
14083 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
14084 }
14085 if let Some(v) = self.op.as_ref() {
14086 match v {
14087 sink_schema_change::Op::AddColumns(v) => {
14088 struct_ser.serialize_field("addColumns", v)?;
14089 }
14090 sink_schema_change::Op::DropColumns(v) => {
14091 struct_ser.serialize_field("dropColumns", v)?;
14092 }
14093 }
14094 }
14095 struct_ser.end()
14096 }
14097}
14098impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
14099 #[allow(deprecated)]
14100 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14101 where
14102 D: serde::Deserializer<'de>,
14103 {
14104 const FIELDS: &[&str] = &[
14105 "original_schema",
14106 "originalSchema",
14107 "add_columns",
14108 "addColumns",
14109 "drop_columns",
14110 "dropColumns",
14111 ];
14112
14113 #[allow(clippy::enum_variant_names)]
14114 enum GeneratedField {
14115 OriginalSchema,
14116 AddColumns,
14117 DropColumns,
14118 }
14119 impl<'de> serde::Deserialize<'de> for GeneratedField {
14120 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14121 where
14122 D: serde::Deserializer<'de>,
14123 {
14124 struct GeneratedVisitor;
14125
14126 impl serde::de::Visitor<'_> for GeneratedVisitor {
14127 type Value = GeneratedField;
14128
14129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14130 write!(formatter, "expected one of: {:?}", &FIELDS)
14131 }
14132
14133 #[allow(unused_variables)]
14134 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14135 where
14136 E: serde::de::Error,
14137 {
14138 match value {
14139 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
14140 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
14141 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
14142 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14143 }
14144 }
14145 }
14146 deserializer.deserialize_identifier(GeneratedVisitor)
14147 }
14148 }
14149 struct GeneratedVisitor;
14150 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14151 type Value = SinkSchemaChange;
14152
14153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14154 formatter.write_str("struct stream_plan.SinkSchemaChange")
14155 }
14156
14157 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
14158 where
14159 V: serde::de::MapAccess<'de>,
14160 {
14161 let mut original_schema__ = None;
14162 let mut op__ = None;
14163 while let Some(k) = map_.next_key()? {
14164 match k {
14165 GeneratedField::OriginalSchema => {
14166 if original_schema__.is_some() {
14167 return Err(serde::de::Error::duplicate_field("originalSchema"));
14168 }
14169 original_schema__ = Some(map_.next_value()?);
14170 }
14171 GeneratedField::AddColumns => {
14172 if op__.is_some() {
14173 return Err(serde::de::Error::duplicate_field("addColumns"));
14174 }
14175 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
14176;
14177 }
14178 GeneratedField::DropColumns => {
14179 if op__.is_some() {
14180 return Err(serde::de::Error::duplicate_field("dropColumns"));
14181 }
14182 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
14183;
14184 }
14185 }
14186 }
14187 Ok(SinkSchemaChange {
14188 original_schema: original_schema__.unwrap_or_default(),
14189 op: op__,
14190 })
14191 }
14192 }
14193 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
14194 }
14195}
14196impl serde::Serialize for SortNode {
14197 #[allow(deprecated)]
14198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14199 where
14200 S: serde::Serializer,
14201 {
14202 use serde::ser::SerializeStruct;
14203 let mut len = 0;
14204 if self.state_table.is_some() {
14205 len += 1;
14206 }
14207 if self.sort_column_index != 0 {
14208 len += 1;
14209 }
14210 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
14211 if let Some(v) = self.state_table.as_ref() {
14212 struct_ser.serialize_field("stateTable", v)?;
14213 }
14214 if self.sort_column_index != 0 {
14215 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
14216 }
14217 struct_ser.end()
14218 }
14219}
14220impl<'de> serde::Deserialize<'de> for SortNode {
14221 #[allow(deprecated)]
14222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14223 where
14224 D: serde::Deserializer<'de>,
14225 {
14226 const FIELDS: &[&str] = &[
14227 "state_table",
14228 "stateTable",
14229 "sort_column_index",
14230 "sortColumnIndex",
14231 ];
14232
14233 #[allow(clippy::enum_variant_names)]
14234 enum GeneratedField {
14235 StateTable,
14236 SortColumnIndex,
14237 }
14238 impl<'de> serde::Deserialize<'de> for GeneratedField {
14239 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14240 where
14241 D: serde::Deserializer<'de>,
14242 {
14243 struct GeneratedVisitor;
14244
14245 impl serde::de::Visitor<'_> for GeneratedVisitor {
14246 type Value = GeneratedField;
14247
14248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14249 write!(formatter, "expected one of: {:?}", &FIELDS)
14250 }
14251
14252 #[allow(unused_variables)]
14253 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14254 where
14255 E: serde::de::Error,
14256 {
14257 match value {
14258 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14259 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
14260 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14261 }
14262 }
14263 }
14264 deserializer.deserialize_identifier(GeneratedVisitor)
14265 }
14266 }
14267 struct GeneratedVisitor;
14268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14269 type Value = SortNode;
14270
14271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14272 formatter.write_str("struct stream_plan.SortNode")
14273 }
14274
14275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
14276 where
14277 V: serde::de::MapAccess<'de>,
14278 {
14279 let mut state_table__ = None;
14280 let mut sort_column_index__ = None;
14281 while let Some(k) = map_.next_key()? {
14282 match k {
14283 GeneratedField::StateTable => {
14284 if state_table__.is_some() {
14285 return Err(serde::de::Error::duplicate_field("stateTable"));
14286 }
14287 state_table__ = map_.next_value()?;
14288 }
14289 GeneratedField::SortColumnIndex => {
14290 if sort_column_index__.is_some() {
14291 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
14292 }
14293 sort_column_index__ =
14294 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14295 ;
14296 }
14297 }
14298 }
14299 Ok(SortNode {
14300 state_table: state_table__,
14301 sort_column_index: sort_column_index__.unwrap_or_default(),
14302 })
14303 }
14304 }
14305 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
14306 }
14307}
14308impl serde::Serialize for SourceBackfillNode {
14309 #[allow(deprecated)]
14310 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14311 where
14312 S: serde::Serializer,
14313 {
14314 use serde::ser::SerializeStruct;
14315 let mut len = 0;
14316 if self.upstream_source_id != 0 {
14317 len += 1;
14318 }
14319 if self.row_id_index.is_some() {
14320 len += 1;
14321 }
14322 if !self.columns.is_empty() {
14323 len += 1;
14324 }
14325 if self.info.is_some() {
14326 len += 1;
14327 }
14328 if !self.source_name.is_empty() {
14329 len += 1;
14330 }
14331 if !self.with_properties.is_empty() {
14332 len += 1;
14333 }
14334 if self.rate_limit.is_some() {
14335 len += 1;
14336 }
14337 if self.state_table.is_some() {
14338 len += 1;
14339 }
14340 if !self.secret_refs.is_empty() {
14341 len += 1;
14342 }
14343 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
14344 if self.upstream_source_id != 0 {
14345 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
14346 }
14347 if let Some(v) = self.row_id_index.as_ref() {
14348 struct_ser.serialize_field("rowIdIndex", v)?;
14349 }
14350 if !self.columns.is_empty() {
14351 struct_ser.serialize_field("columns", &self.columns)?;
14352 }
14353 if let Some(v) = self.info.as_ref() {
14354 struct_ser.serialize_field("info", v)?;
14355 }
14356 if !self.source_name.is_empty() {
14357 struct_ser.serialize_field("sourceName", &self.source_name)?;
14358 }
14359 if !self.with_properties.is_empty() {
14360 struct_ser.serialize_field("withProperties", &self.with_properties)?;
14361 }
14362 if let Some(v) = self.rate_limit.as_ref() {
14363 struct_ser.serialize_field("rateLimit", v)?;
14364 }
14365 if let Some(v) = self.state_table.as_ref() {
14366 struct_ser.serialize_field("stateTable", v)?;
14367 }
14368 if !self.secret_refs.is_empty() {
14369 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
14370 }
14371 struct_ser.end()
14372 }
14373}
14374impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
14375 #[allow(deprecated)]
14376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14377 where
14378 D: serde::Deserializer<'de>,
14379 {
14380 const FIELDS: &[&str] = &[
14381 "upstream_source_id",
14382 "upstreamSourceId",
14383 "row_id_index",
14384 "rowIdIndex",
14385 "columns",
14386 "info",
14387 "source_name",
14388 "sourceName",
14389 "with_properties",
14390 "withProperties",
14391 "rate_limit",
14392 "rateLimit",
14393 "state_table",
14394 "stateTable",
14395 "secret_refs",
14396 "secretRefs",
14397 ];
14398
14399 #[allow(clippy::enum_variant_names)]
14400 enum GeneratedField {
14401 UpstreamSourceId,
14402 RowIdIndex,
14403 Columns,
14404 Info,
14405 SourceName,
14406 WithProperties,
14407 RateLimit,
14408 StateTable,
14409 SecretRefs,
14410 }
14411 impl<'de> serde::Deserialize<'de> for GeneratedField {
14412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14413 where
14414 D: serde::Deserializer<'de>,
14415 {
14416 struct GeneratedVisitor;
14417
14418 impl serde::de::Visitor<'_> for GeneratedVisitor {
14419 type Value = GeneratedField;
14420
14421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14422 write!(formatter, "expected one of: {:?}", &FIELDS)
14423 }
14424
14425 #[allow(unused_variables)]
14426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14427 where
14428 E: serde::de::Error,
14429 {
14430 match value {
14431 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
14432 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
14433 "columns" => Ok(GeneratedField::Columns),
14434 "info" => Ok(GeneratedField::Info),
14435 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
14436 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
14437 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14438 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14439 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
14440 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14441 }
14442 }
14443 }
14444 deserializer.deserialize_identifier(GeneratedVisitor)
14445 }
14446 }
14447 struct GeneratedVisitor;
14448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14449 type Value = SourceBackfillNode;
14450
14451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14452 formatter.write_str("struct stream_plan.SourceBackfillNode")
14453 }
14454
14455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
14456 where
14457 V: serde::de::MapAccess<'de>,
14458 {
14459 let mut upstream_source_id__ = None;
14460 let mut row_id_index__ = None;
14461 let mut columns__ = None;
14462 let mut info__ = None;
14463 let mut source_name__ = None;
14464 let mut with_properties__ = None;
14465 let mut rate_limit__ = None;
14466 let mut state_table__ = None;
14467 let mut secret_refs__ = None;
14468 while let Some(k) = map_.next_key()? {
14469 match k {
14470 GeneratedField::UpstreamSourceId => {
14471 if upstream_source_id__.is_some() {
14472 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
14473 }
14474 upstream_source_id__ =
14475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14476 ;
14477 }
14478 GeneratedField::RowIdIndex => {
14479 if row_id_index__.is_some() {
14480 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
14481 }
14482 row_id_index__ =
14483 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14484 ;
14485 }
14486 GeneratedField::Columns => {
14487 if columns__.is_some() {
14488 return Err(serde::de::Error::duplicate_field("columns"));
14489 }
14490 columns__ = Some(map_.next_value()?);
14491 }
14492 GeneratedField::Info => {
14493 if info__.is_some() {
14494 return Err(serde::de::Error::duplicate_field("info"));
14495 }
14496 info__ = map_.next_value()?;
14497 }
14498 GeneratedField::SourceName => {
14499 if source_name__.is_some() {
14500 return Err(serde::de::Error::duplicate_field("sourceName"));
14501 }
14502 source_name__ = Some(map_.next_value()?);
14503 }
14504 GeneratedField::WithProperties => {
14505 if with_properties__.is_some() {
14506 return Err(serde::de::Error::duplicate_field("withProperties"));
14507 }
14508 with_properties__ = Some(
14509 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14510 );
14511 }
14512 GeneratedField::RateLimit => {
14513 if rate_limit__.is_some() {
14514 return Err(serde::de::Error::duplicate_field("rateLimit"));
14515 }
14516 rate_limit__ =
14517 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14518 ;
14519 }
14520 GeneratedField::StateTable => {
14521 if state_table__.is_some() {
14522 return Err(serde::de::Error::duplicate_field("stateTable"));
14523 }
14524 state_table__ = map_.next_value()?;
14525 }
14526 GeneratedField::SecretRefs => {
14527 if secret_refs__.is_some() {
14528 return Err(serde::de::Error::duplicate_field("secretRefs"));
14529 }
14530 secret_refs__ = Some(
14531 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14532 );
14533 }
14534 }
14535 }
14536 Ok(SourceBackfillNode {
14537 upstream_source_id: upstream_source_id__.unwrap_or_default(),
14538 row_id_index: row_id_index__,
14539 columns: columns__.unwrap_or_default(),
14540 info: info__,
14541 source_name: source_name__.unwrap_or_default(),
14542 with_properties: with_properties__.unwrap_or_default(),
14543 rate_limit: rate_limit__,
14544 state_table: state_table__,
14545 secret_refs: secret_refs__.unwrap_or_default(),
14546 })
14547 }
14548 }
14549 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
14550 }
14551}
14552impl serde::Serialize for SourceChangeSplitMutation {
14553 #[allow(deprecated)]
14554 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14555 where
14556 S: serde::Serializer,
14557 {
14558 use serde::ser::SerializeStruct;
14559 let mut len = 0;
14560 if !self.actor_splits.is_empty() {
14561 len += 1;
14562 }
14563 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
14564 if !self.actor_splits.is_empty() {
14565 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14566 }
14567 struct_ser.end()
14568 }
14569}
14570impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
14571 #[allow(deprecated)]
14572 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14573 where
14574 D: serde::Deserializer<'de>,
14575 {
14576 const FIELDS: &[&str] = &[
14577 "actor_splits",
14578 "actorSplits",
14579 ];
14580
14581 #[allow(clippy::enum_variant_names)]
14582 enum GeneratedField {
14583 ActorSplits,
14584 }
14585 impl<'de> serde::Deserialize<'de> for GeneratedField {
14586 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14587 where
14588 D: serde::Deserializer<'de>,
14589 {
14590 struct GeneratedVisitor;
14591
14592 impl serde::de::Visitor<'_> for GeneratedVisitor {
14593 type Value = GeneratedField;
14594
14595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14596 write!(formatter, "expected one of: {:?}", &FIELDS)
14597 }
14598
14599 #[allow(unused_variables)]
14600 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14601 where
14602 E: serde::de::Error,
14603 {
14604 match value {
14605 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14606 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14607 }
14608 }
14609 }
14610 deserializer.deserialize_identifier(GeneratedVisitor)
14611 }
14612 }
14613 struct GeneratedVisitor;
14614 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14615 type Value = SourceChangeSplitMutation;
14616
14617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14618 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
14619 }
14620
14621 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
14622 where
14623 V: serde::de::MapAccess<'de>,
14624 {
14625 let mut actor_splits__ = None;
14626 while let Some(k) = map_.next_key()? {
14627 match k {
14628 GeneratedField::ActorSplits => {
14629 if actor_splits__.is_some() {
14630 return Err(serde::de::Error::duplicate_field("actorSplits"));
14631 }
14632 actor_splits__ = Some(
14633 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14634 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14635 );
14636 }
14637 }
14638 }
14639 Ok(SourceChangeSplitMutation {
14640 actor_splits: actor_splits__.unwrap_or_default(),
14641 })
14642 }
14643 }
14644 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
14645 }
14646}
14647impl serde::Serialize for SourceNode {
14648 #[allow(deprecated)]
14649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14650 where
14651 S: serde::Serializer,
14652 {
14653 use serde::ser::SerializeStruct;
14654 let mut len = 0;
14655 if self.source_inner.is_some() {
14656 len += 1;
14657 }
14658 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
14659 if let Some(v) = self.source_inner.as_ref() {
14660 struct_ser.serialize_field("sourceInner", v)?;
14661 }
14662 struct_ser.end()
14663 }
14664}
14665impl<'de> serde::Deserialize<'de> for SourceNode {
14666 #[allow(deprecated)]
14667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14668 where
14669 D: serde::Deserializer<'de>,
14670 {
14671 const FIELDS: &[&str] = &[
14672 "source_inner",
14673 "sourceInner",
14674 ];
14675
14676 #[allow(clippy::enum_variant_names)]
14677 enum GeneratedField {
14678 SourceInner,
14679 }
14680 impl<'de> serde::Deserialize<'de> for GeneratedField {
14681 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14682 where
14683 D: serde::Deserializer<'de>,
14684 {
14685 struct GeneratedVisitor;
14686
14687 impl serde::de::Visitor<'_> for GeneratedVisitor {
14688 type Value = GeneratedField;
14689
14690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14691 write!(formatter, "expected one of: {:?}", &FIELDS)
14692 }
14693
14694 #[allow(unused_variables)]
14695 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14696 where
14697 E: serde::de::Error,
14698 {
14699 match value {
14700 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
14701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14702 }
14703 }
14704 }
14705 deserializer.deserialize_identifier(GeneratedVisitor)
14706 }
14707 }
14708 struct GeneratedVisitor;
14709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14710 type Value = SourceNode;
14711
14712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14713 formatter.write_str("struct stream_plan.SourceNode")
14714 }
14715
14716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
14717 where
14718 V: serde::de::MapAccess<'de>,
14719 {
14720 let mut source_inner__ = None;
14721 while let Some(k) = map_.next_key()? {
14722 match k {
14723 GeneratedField::SourceInner => {
14724 if source_inner__.is_some() {
14725 return Err(serde::de::Error::duplicate_field("sourceInner"));
14726 }
14727 source_inner__ = map_.next_value()?;
14728 }
14729 }
14730 }
14731 Ok(SourceNode {
14732 source_inner: source_inner__,
14733 })
14734 }
14735 }
14736 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
14737 }
14738}
14739impl serde::Serialize for StartFragmentBackfillMutation {
14740 #[allow(deprecated)]
14741 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14742 where
14743 S: serde::Serializer,
14744 {
14745 use serde::ser::SerializeStruct;
14746 let mut len = 0;
14747 if !self.fragment_ids.is_empty() {
14748 len += 1;
14749 }
14750 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
14751 if !self.fragment_ids.is_empty() {
14752 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
14753 }
14754 struct_ser.end()
14755 }
14756}
14757impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
14758 #[allow(deprecated)]
14759 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14760 where
14761 D: serde::Deserializer<'de>,
14762 {
14763 const FIELDS: &[&str] = &[
14764 "fragment_ids",
14765 "fragmentIds",
14766 ];
14767
14768 #[allow(clippy::enum_variant_names)]
14769 enum GeneratedField {
14770 FragmentIds,
14771 }
14772 impl<'de> serde::Deserialize<'de> for GeneratedField {
14773 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14774 where
14775 D: serde::Deserializer<'de>,
14776 {
14777 struct GeneratedVisitor;
14778
14779 impl serde::de::Visitor<'_> for GeneratedVisitor {
14780 type Value = GeneratedField;
14781
14782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14783 write!(formatter, "expected one of: {:?}", &FIELDS)
14784 }
14785
14786 #[allow(unused_variables)]
14787 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14788 where
14789 E: serde::de::Error,
14790 {
14791 match value {
14792 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
14793 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14794 }
14795 }
14796 }
14797 deserializer.deserialize_identifier(GeneratedVisitor)
14798 }
14799 }
14800 struct GeneratedVisitor;
14801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14802 type Value = StartFragmentBackfillMutation;
14803
14804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14805 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
14806 }
14807
14808 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
14809 where
14810 V: serde::de::MapAccess<'de>,
14811 {
14812 let mut fragment_ids__ = None;
14813 while let Some(k) = map_.next_key()? {
14814 match k {
14815 GeneratedField::FragmentIds => {
14816 if fragment_ids__.is_some() {
14817 return Err(serde::de::Error::duplicate_field("fragmentIds"));
14818 }
14819 fragment_ids__ =
14820 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14821 .into_iter().map(|x| x.0).collect())
14822 ;
14823 }
14824 }
14825 }
14826 Ok(StartFragmentBackfillMutation {
14827 fragment_ids: fragment_ids__.unwrap_or_default(),
14828 })
14829 }
14830 }
14831 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
14832 }
14833}
14834impl serde::Serialize for StopMutation {
14835 #[allow(deprecated)]
14836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14837 where
14838 S: serde::Serializer,
14839 {
14840 use serde::ser::SerializeStruct;
14841 let mut len = 0;
14842 if !self.actors.is_empty() {
14843 len += 1;
14844 }
14845 if !self.dropped_sink_fragments.is_empty() {
14846 len += 1;
14847 }
14848 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
14849 if !self.actors.is_empty() {
14850 struct_ser.serialize_field("actors", &self.actors)?;
14851 }
14852 if !self.dropped_sink_fragments.is_empty() {
14853 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
14854 }
14855 struct_ser.end()
14856 }
14857}
14858impl<'de> serde::Deserialize<'de> for StopMutation {
14859 #[allow(deprecated)]
14860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14861 where
14862 D: serde::Deserializer<'de>,
14863 {
14864 const FIELDS: &[&str] = &[
14865 "actors",
14866 "dropped_sink_fragments",
14867 "droppedSinkFragments",
14868 ];
14869
14870 #[allow(clippy::enum_variant_names)]
14871 enum GeneratedField {
14872 Actors,
14873 DroppedSinkFragments,
14874 }
14875 impl<'de> serde::Deserialize<'de> for GeneratedField {
14876 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14877 where
14878 D: serde::Deserializer<'de>,
14879 {
14880 struct GeneratedVisitor;
14881
14882 impl serde::de::Visitor<'_> for GeneratedVisitor {
14883 type Value = GeneratedField;
14884
14885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14886 write!(formatter, "expected one of: {:?}", &FIELDS)
14887 }
14888
14889 #[allow(unused_variables)]
14890 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14891 where
14892 E: serde::de::Error,
14893 {
14894 match value {
14895 "actors" => Ok(GeneratedField::Actors),
14896 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
14897 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14898 }
14899 }
14900 }
14901 deserializer.deserialize_identifier(GeneratedVisitor)
14902 }
14903 }
14904 struct GeneratedVisitor;
14905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14906 type Value = StopMutation;
14907
14908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14909 formatter.write_str("struct stream_plan.StopMutation")
14910 }
14911
14912 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
14913 where
14914 V: serde::de::MapAccess<'de>,
14915 {
14916 let mut actors__ = None;
14917 let mut dropped_sink_fragments__ = None;
14918 while let Some(k) = map_.next_key()? {
14919 match k {
14920 GeneratedField::Actors => {
14921 if actors__.is_some() {
14922 return Err(serde::de::Error::duplicate_field("actors"));
14923 }
14924 actors__ =
14925 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14926 .into_iter().map(|x| x.0).collect())
14927 ;
14928 }
14929 GeneratedField::DroppedSinkFragments => {
14930 if dropped_sink_fragments__.is_some() {
14931 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
14932 }
14933 dropped_sink_fragments__ =
14934 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14935 .into_iter().map(|x| x.0).collect())
14936 ;
14937 }
14938 }
14939 }
14940 Ok(StopMutation {
14941 actors: actors__.unwrap_or_default(),
14942 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
14943 })
14944 }
14945 }
14946 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
14947 }
14948}
14949impl serde::Serialize for StreamActor {
14950 #[allow(deprecated)]
14951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14952 where
14953 S: serde::Serializer,
14954 {
14955 use serde::ser::SerializeStruct;
14956 let mut len = 0;
14957 if self.actor_id != 0 {
14958 len += 1;
14959 }
14960 if self.fragment_id != 0 {
14961 len += 1;
14962 }
14963 if !self.dispatcher.is_empty() {
14964 len += 1;
14965 }
14966 if self.vnode_bitmap.is_some() {
14967 len += 1;
14968 }
14969 if !self.mview_definition.is_empty() {
14970 len += 1;
14971 }
14972 if self.expr_context.is_some() {
14973 len += 1;
14974 }
14975 if !self.config_override.is_empty() {
14976 len += 1;
14977 }
14978 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
14979 if self.actor_id != 0 {
14980 struct_ser.serialize_field("actorId", &self.actor_id)?;
14981 }
14982 if self.fragment_id != 0 {
14983 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
14984 }
14985 if !self.dispatcher.is_empty() {
14986 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
14987 }
14988 if let Some(v) = self.vnode_bitmap.as_ref() {
14989 struct_ser.serialize_field("vnodeBitmap", v)?;
14990 }
14991 if !self.mview_definition.is_empty() {
14992 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
14993 }
14994 if let Some(v) = self.expr_context.as_ref() {
14995 struct_ser.serialize_field("exprContext", v)?;
14996 }
14997 if !self.config_override.is_empty() {
14998 struct_ser.serialize_field("configOverride", &self.config_override)?;
14999 }
15000 struct_ser.end()
15001 }
15002}
15003impl<'de> serde::Deserialize<'de> for StreamActor {
15004 #[allow(deprecated)]
15005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15006 where
15007 D: serde::Deserializer<'de>,
15008 {
15009 const FIELDS: &[&str] = &[
15010 "actor_id",
15011 "actorId",
15012 "fragment_id",
15013 "fragmentId",
15014 "dispatcher",
15015 "vnode_bitmap",
15016 "vnodeBitmap",
15017 "mview_definition",
15018 "mviewDefinition",
15019 "expr_context",
15020 "exprContext",
15021 "config_override",
15022 "configOverride",
15023 ];
15024
15025 #[allow(clippy::enum_variant_names)]
15026 enum GeneratedField {
15027 ActorId,
15028 FragmentId,
15029 Dispatcher,
15030 VnodeBitmap,
15031 MviewDefinition,
15032 ExprContext,
15033 ConfigOverride,
15034 }
15035 impl<'de> serde::Deserialize<'de> for GeneratedField {
15036 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15037 where
15038 D: serde::Deserializer<'de>,
15039 {
15040 struct GeneratedVisitor;
15041
15042 impl serde::de::Visitor<'_> for GeneratedVisitor {
15043 type Value = GeneratedField;
15044
15045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15046 write!(formatter, "expected one of: {:?}", &FIELDS)
15047 }
15048
15049 #[allow(unused_variables)]
15050 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15051 where
15052 E: serde::de::Error,
15053 {
15054 match value {
15055 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15056 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
15057 "dispatcher" => Ok(GeneratedField::Dispatcher),
15058 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
15059 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
15060 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
15061 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
15062 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15063 }
15064 }
15065 }
15066 deserializer.deserialize_identifier(GeneratedVisitor)
15067 }
15068 }
15069 struct GeneratedVisitor;
15070 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15071 type Value = StreamActor;
15072
15073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15074 formatter.write_str("struct stream_plan.StreamActor")
15075 }
15076
15077 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
15078 where
15079 V: serde::de::MapAccess<'de>,
15080 {
15081 let mut actor_id__ = None;
15082 let mut fragment_id__ = None;
15083 let mut dispatcher__ = None;
15084 let mut vnode_bitmap__ = None;
15085 let mut mview_definition__ = None;
15086 let mut expr_context__ = None;
15087 let mut config_override__ = None;
15088 while let Some(k) = map_.next_key()? {
15089 match k {
15090 GeneratedField::ActorId => {
15091 if actor_id__.is_some() {
15092 return Err(serde::de::Error::duplicate_field("actorId"));
15093 }
15094 actor_id__ =
15095 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15096 ;
15097 }
15098 GeneratedField::FragmentId => {
15099 if fragment_id__.is_some() {
15100 return Err(serde::de::Error::duplicate_field("fragmentId"));
15101 }
15102 fragment_id__ =
15103 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15104 ;
15105 }
15106 GeneratedField::Dispatcher => {
15107 if dispatcher__.is_some() {
15108 return Err(serde::de::Error::duplicate_field("dispatcher"));
15109 }
15110 dispatcher__ = Some(map_.next_value()?);
15111 }
15112 GeneratedField::VnodeBitmap => {
15113 if vnode_bitmap__.is_some() {
15114 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
15115 }
15116 vnode_bitmap__ = map_.next_value()?;
15117 }
15118 GeneratedField::MviewDefinition => {
15119 if mview_definition__.is_some() {
15120 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
15121 }
15122 mview_definition__ = Some(map_.next_value()?);
15123 }
15124 GeneratedField::ExprContext => {
15125 if expr_context__.is_some() {
15126 return Err(serde::de::Error::duplicate_field("exprContext"));
15127 }
15128 expr_context__ = map_.next_value()?;
15129 }
15130 GeneratedField::ConfigOverride => {
15131 if config_override__.is_some() {
15132 return Err(serde::de::Error::duplicate_field("configOverride"));
15133 }
15134 config_override__ = Some(map_.next_value()?);
15135 }
15136 }
15137 }
15138 Ok(StreamActor {
15139 actor_id: actor_id__.unwrap_or_default(),
15140 fragment_id: fragment_id__.unwrap_or_default(),
15141 dispatcher: dispatcher__.unwrap_or_default(),
15142 vnode_bitmap: vnode_bitmap__,
15143 mview_definition: mview_definition__.unwrap_or_default(),
15144 expr_context: expr_context__,
15145 config_override: config_override__.unwrap_or_default(),
15146 })
15147 }
15148 }
15149 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
15150 }
15151}
15152impl serde::Serialize for StreamCdcScanNode {
15153 #[allow(deprecated)]
15154 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15155 where
15156 S: serde::Serializer,
15157 {
15158 use serde::ser::SerializeStruct;
15159 let mut len = 0;
15160 if self.table_id != 0 {
15161 len += 1;
15162 }
15163 if !self.upstream_column_ids.is_empty() {
15164 len += 1;
15165 }
15166 if !self.output_indices.is_empty() {
15167 len += 1;
15168 }
15169 if self.state_table.is_some() {
15170 len += 1;
15171 }
15172 if self.cdc_table_desc.is_some() {
15173 len += 1;
15174 }
15175 if self.rate_limit.is_some() {
15176 len += 1;
15177 }
15178 if self.disable_backfill {
15179 len += 1;
15180 }
15181 if self.options.is_some() {
15182 len += 1;
15183 }
15184 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
15185 if self.table_id != 0 {
15186 struct_ser.serialize_field("tableId", &self.table_id)?;
15187 }
15188 if !self.upstream_column_ids.is_empty() {
15189 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
15190 }
15191 if !self.output_indices.is_empty() {
15192 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15193 }
15194 if let Some(v) = self.state_table.as_ref() {
15195 struct_ser.serialize_field("stateTable", v)?;
15196 }
15197 if let Some(v) = self.cdc_table_desc.as_ref() {
15198 struct_ser.serialize_field("cdcTableDesc", v)?;
15199 }
15200 if let Some(v) = self.rate_limit.as_ref() {
15201 struct_ser.serialize_field("rateLimit", v)?;
15202 }
15203 if self.disable_backfill {
15204 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
15205 }
15206 if let Some(v) = self.options.as_ref() {
15207 struct_ser.serialize_field("options", v)?;
15208 }
15209 struct_ser.end()
15210 }
15211}
15212impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
15213 #[allow(deprecated)]
15214 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15215 where
15216 D: serde::Deserializer<'de>,
15217 {
15218 const FIELDS: &[&str] = &[
15219 "table_id",
15220 "tableId",
15221 "upstream_column_ids",
15222 "upstreamColumnIds",
15223 "output_indices",
15224 "outputIndices",
15225 "state_table",
15226 "stateTable",
15227 "cdc_table_desc",
15228 "cdcTableDesc",
15229 "rate_limit",
15230 "rateLimit",
15231 "disable_backfill",
15232 "disableBackfill",
15233 "options",
15234 ];
15235
15236 #[allow(clippy::enum_variant_names)]
15237 enum GeneratedField {
15238 TableId,
15239 UpstreamColumnIds,
15240 OutputIndices,
15241 StateTable,
15242 CdcTableDesc,
15243 RateLimit,
15244 DisableBackfill,
15245 Options,
15246 }
15247 impl<'de> serde::Deserialize<'de> for GeneratedField {
15248 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15249 where
15250 D: serde::Deserializer<'de>,
15251 {
15252 struct GeneratedVisitor;
15253
15254 impl serde::de::Visitor<'_> for GeneratedVisitor {
15255 type Value = GeneratedField;
15256
15257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15258 write!(formatter, "expected one of: {:?}", &FIELDS)
15259 }
15260
15261 #[allow(unused_variables)]
15262 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15263 where
15264 E: serde::de::Error,
15265 {
15266 match value {
15267 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15268 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
15269 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15270 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15271 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
15272 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15273 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
15274 "options" => Ok(GeneratedField::Options),
15275 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15276 }
15277 }
15278 }
15279 deserializer.deserialize_identifier(GeneratedVisitor)
15280 }
15281 }
15282 struct GeneratedVisitor;
15283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15284 type Value = StreamCdcScanNode;
15285
15286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15287 formatter.write_str("struct stream_plan.StreamCdcScanNode")
15288 }
15289
15290 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
15291 where
15292 V: serde::de::MapAccess<'de>,
15293 {
15294 let mut table_id__ = None;
15295 let mut upstream_column_ids__ = None;
15296 let mut output_indices__ = None;
15297 let mut state_table__ = None;
15298 let mut cdc_table_desc__ = None;
15299 let mut rate_limit__ = None;
15300 let mut disable_backfill__ = None;
15301 let mut options__ = None;
15302 while let Some(k) = map_.next_key()? {
15303 match k {
15304 GeneratedField::TableId => {
15305 if table_id__.is_some() {
15306 return Err(serde::de::Error::duplicate_field("tableId"));
15307 }
15308 table_id__ =
15309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15310 ;
15311 }
15312 GeneratedField::UpstreamColumnIds => {
15313 if upstream_column_ids__.is_some() {
15314 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15315 }
15316 upstream_column_ids__ =
15317 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15318 .into_iter().map(|x| x.0).collect())
15319 ;
15320 }
15321 GeneratedField::OutputIndices => {
15322 if output_indices__.is_some() {
15323 return Err(serde::de::Error::duplicate_field("outputIndices"));
15324 }
15325 output_indices__ =
15326 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15327 .into_iter().map(|x| x.0).collect())
15328 ;
15329 }
15330 GeneratedField::StateTable => {
15331 if state_table__.is_some() {
15332 return Err(serde::de::Error::duplicate_field("stateTable"));
15333 }
15334 state_table__ = map_.next_value()?;
15335 }
15336 GeneratedField::CdcTableDesc => {
15337 if cdc_table_desc__.is_some() {
15338 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
15339 }
15340 cdc_table_desc__ = map_.next_value()?;
15341 }
15342 GeneratedField::RateLimit => {
15343 if rate_limit__.is_some() {
15344 return Err(serde::de::Error::duplicate_field("rateLimit"));
15345 }
15346 rate_limit__ =
15347 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15348 ;
15349 }
15350 GeneratedField::DisableBackfill => {
15351 if disable_backfill__.is_some() {
15352 return Err(serde::de::Error::duplicate_field("disableBackfill"));
15353 }
15354 disable_backfill__ = Some(map_.next_value()?);
15355 }
15356 GeneratedField::Options => {
15357 if options__.is_some() {
15358 return Err(serde::de::Error::duplicate_field("options"));
15359 }
15360 options__ = map_.next_value()?;
15361 }
15362 }
15363 }
15364 Ok(StreamCdcScanNode {
15365 table_id: table_id__.unwrap_or_default(),
15366 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15367 output_indices: output_indices__.unwrap_or_default(),
15368 state_table: state_table__,
15369 cdc_table_desc: cdc_table_desc__,
15370 rate_limit: rate_limit__,
15371 disable_backfill: disable_backfill__.unwrap_or_default(),
15372 options: options__,
15373 })
15374 }
15375 }
15376 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
15377 }
15378}
15379impl serde::Serialize for StreamCdcScanOptions {
15380 #[allow(deprecated)]
15381 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15382 where
15383 S: serde::Serializer,
15384 {
15385 use serde::ser::SerializeStruct;
15386 let mut len = 0;
15387 if self.disable_backfill {
15388 len += 1;
15389 }
15390 if self.snapshot_barrier_interval != 0 {
15391 len += 1;
15392 }
15393 if self.snapshot_batch_size != 0 {
15394 len += 1;
15395 }
15396 if self.backfill_parallelism != 0 {
15397 len += 1;
15398 }
15399 if self.backfill_num_rows_per_split != 0 {
15400 len += 1;
15401 }
15402 if self.backfill_as_even_splits {
15403 len += 1;
15404 }
15405 if self.backfill_split_pk_column_index != 0 {
15406 len += 1;
15407 }
15408 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
15409 if self.disable_backfill {
15410 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
15411 }
15412 if self.snapshot_barrier_interval != 0 {
15413 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
15414 }
15415 if self.snapshot_batch_size != 0 {
15416 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
15417 }
15418 if self.backfill_parallelism != 0 {
15419 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
15420 }
15421 if self.backfill_num_rows_per_split != 0 {
15422 #[allow(clippy::needless_borrow)]
15423 #[allow(clippy::needless_borrows_for_generic_args)]
15424 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
15425 }
15426 if self.backfill_as_even_splits {
15427 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
15428 }
15429 if self.backfill_split_pk_column_index != 0 {
15430 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
15431 }
15432 struct_ser.end()
15433 }
15434}
15435impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
15436 #[allow(deprecated)]
15437 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15438 where
15439 D: serde::Deserializer<'de>,
15440 {
15441 const FIELDS: &[&str] = &[
15442 "disable_backfill",
15443 "disableBackfill",
15444 "snapshot_barrier_interval",
15445 "snapshotBarrierInterval",
15446 "snapshot_batch_size",
15447 "snapshotBatchSize",
15448 "backfill_parallelism",
15449 "backfillParallelism",
15450 "backfill_num_rows_per_split",
15451 "backfillNumRowsPerSplit",
15452 "backfill_as_even_splits",
15453 "backfillAsEvenSplits",
15454 "backfill_split_pk_column_index",
15455 "backfillSplitPkColumnIndex",
15456 ];
15457
15458 #[allow(clippy::enum_variant_names)]
15459 enum GeneratedField {
15460 DisableBackfill,
15461 SnapshotBarrierInterval,
15462 SnapshotBatchSize,
15463 BackfillParallelism,
15464 BackfillNumRowsPerSplit,
15465 BackfillAsEvenSplits,
15466 BackfillSplitPkColumnIndex,
15467 }
15468 impl<'de> serde::Deserialize<'de> for GeneratedField {
15469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15470 where
15471 D: serde::Deserializer<'de>,
15472 {
15473 struct GeneratedVisitor;
15474
15475 impl serde::de::Visitor<'_> for GeneratedVisitor {
15476 type Value = GeneratedField;
15477
15478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15479 write!(formatter, "expected one of: {:?}", &FIELDS)
15480 }
15481
15482 #[allow(unused_variables)]
15483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15484 where
15485 E: serde::de::Error,
15486 {
15487 match value {
15488 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
15489 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
15490 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
15491 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
15492 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
15493 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
15494 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
15495 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15496 }
15497 }
15498 }
15499 deserializer.deserialize_identifier(GeneratedVisitor)
15500 }
15501 }
15502 struct GeneratedVisitor;
15503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15504 type Value = StreamCdcScanOptions;
15505
15506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15507 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
15508 }
15509
15510 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
15511 where
15512 V: serde::de::MapAccess<'de>,
15513 {
15514 let mut disable_backfill__ = None;
15515 let mut snapshot_barrier_interval__ = None;
15516 let mut snapshot_batch_size__ = None;
15517 let mut backfill_parallelism__ = None;
15518 let mut backfill_num_rows_per_split__ = None;
15519 let mut backfill_as_even_splits__ = None;
15520 let mut backfill_split_pk_column_index__ = None;
15521 while let Some(k) = map_.next_key()? {
15522 match k {
15523 GeneratedField::DisableBackfill => {
15524 if disable_backfill__.is_some() {
15525 return Err(serde::de::Error::duplicate_field("disableBackfill"));
15526 }
15527 disable_backfill__ = Some(map_.next_value()?);
15528 }
15529 GeneratedField::SnapshotBarrierInterval => {
15530 if snapshot_barrier_interval__.is_some() {
15531 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
15532 }
15533 snapshot_barrier_interval__ =
15534 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15535 ;
15536 }
15537 GeneratedField::SnapshotBatchSize => {
15538 if snapshot_batch_size__.is_some() {
15539 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
15540 }
15541 snapshot_batch_size__ =
15542 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15543 ;
15544 }
15545 GeneratedField::BackfillParallelism => {
15546 if backfill_parallelism__.is_some() {
15547 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
15548 }
15549 backfill_parallelism__ =
15550 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15551 ;
15552 }
15553 GeneratedField::BackfillNumRowsPerSplit => {
15554 if backfill_num_rows_per_split__.is_some() {
15555 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
15556 }
15557 backfill_num_rows_per_split__ =
15558 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15559 ;
15560 }
15561 GeneratedField::BackfillAsEvenSplits => {
15562 if backfill_as_even_splits__.is_some() {
15563 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
15564 }
15565 backfill_as_even_splits__ = Some(map_.next_value()?);
15566 }
15567 GeneratedField::BackfillSplitPkColumnIndex => {
15568 if backfill_split_pk_column_index__.is_some() {
15569 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
15570 }
15571 backfill_split_pk_column_index__ =
15572 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15573 ;
15574 }
15575 }
15576 }
15577 Ok(StreamCdcScanOptions {
15578 disable_backfill: disable_backfill__.unwrap_or_default(),
15579 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
15580 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
15581 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
15582 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
15583 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
15584 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
15585 })
15586 }
15587 }
15588 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
15589 }
15590}
15591impl serde::Serialize for StreamContext {
15592 #[allow(deprecated)]
15593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15594 where
15595 S: serde::Serializer,
15596 {
15597 use serde::ser::SerializeStruct;
15598 let mut len = 0;
15599 if !self.timezone.is_empty() {
15600 len += 1;
15601 }
15602 if !self.config_override.is_empty() {
15603 len += 1;
15604 }
15605 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
15606 if !self.timezone.is_empty() {
15607 struct_ser.serialize_field("timezone", &self.timezone)?;
15608 }
15609 if !self.config_override.is_empty() {
15610 struct_ser.serialize_field("configOverride", &self.config_override)?;
15611 }
15612 struct_ser.end()
15613 }
15614}
15615impl<'de> serde::Deserialize<'de> for StreamContext {
15616 #[allow(deprecated)]
15617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15618 where
15619 D: serde::Deserializer<'de>,
15620 {
15621 const FIELDS: &[&str] = &[
15622 "timezone",
15623 "config_override",
15624 "configOverride",
15625 ];
15626
15627 #[allow(clippy::enum_variant_names)]
15628 enum GeneratedField {
15629 Timezone,
15630 ConfigOverride,
15631 }
15632 impl<'de> serde::Deserialize<'de> for GeneratedField {
15633 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15634 where
15635 D: serde::Deserializer<'de>,
15636 {
15637 struct GeneratedVisitor;
15638
15639 impl serde::de::Visitor<'_> for GeneratedVisitor {
15640 type Value = GeneratedField;
15641
15642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15643 write!(formatter, "expected one of: {:?}", &FIELDS)
15644 }
15645
15646 #[allow(unused_variables)]
15647 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15648 where
15649 E: serde::de::Error,
15650 {
15651 match value {
15652 "timezone" => Ok(GeneratedField::Timezone),
15653 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
15654 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15655 }
15656 }
15657 }
15658 deserializer.deserialize_identifier(GeneratedVisitor)
15659 }
15660 }
15661 struct GeneratedVisitor;
15662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15663 type Value = StreamContext;
15664
15665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15666 formatter.write_str("struct stream_plan.StreamContext")
15667 }
15668
15669 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
15670 where
15671 V: serde::de::MapAccess<'de>,
15672 {
15673 let mut timezone__ = None;
15674 let mut config_override__ = None;
15675 while let Some(k) = map_.next_key()? {
15676 match k {
15677 GeneratedField::Timezone => {
15678 if timezone__.is_some() {
15679 return Err(serde::de::Error::duplicate_field("timezone"));
15680 }
15681 timezone__ = Some(map_.next_value()?);
15682 }
15683 GeneratedField::ConfigOverride => {
15684 if config_override__.is_some() {
15685 return Err(serde::de::Error::duplicate_field("configOverride"));
15686 }
15687 config_override__ = Some(map_.next_value()?);
15688 }
15689 }
15690 }
15691 Ok(StreamContext {
15692 timezone: timezone__.unwrap_or_default(),
15693 config_override: config_override__.unwrap_or_default(),
15694 })
15695 }
15696 }
15697 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
15698 }
15699}
15700impl serde::Serialize for StreamFragmentGraph {
15701 #[allow(deprecated)]
15702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15703 where
15704 S: serde::Serializer,
15705 {
15706 use serde::ser::SerializeStruct;
15707 let mut len = 0;
15708 if !self.fragments.is_empty() {
15709 len += 1;
15710 }
15711 if !self.edges.is_empty() {
15712 len += 1;
15713 }
15714 if !self.dependent_table_ids.is_empty() {
15715 len += 1;
15716 }
15717 if self.table_ids_cnt != 0 {
15718 len += 1;
15719 }
15720 if self.ctx.is_some() {
15721 len += 1;
15722 }
15723 if self.parallelism.is_some() {
15724 len += 1;
15725 }
15726 if self.backfill_parallelism.is_some() {
15727 len += 1;
15728 }
15729 if !self.adaptive_parallelism_strategy.is_empty() {
15730 len += 1;
15731 }
15732 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
15733 len += 1;
15734 }
15735 if self.max_parallelism != 0 {
15736 len += 1;
15737 }
15738 if self.backfill_order.is_some() {
15739 len += 1;
15740 }
15741 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
15742 if !self.fragments.is_empty() {
15743 struct_ser.serialize_field("fragments", &self.fragments)?;
15744 }
15745 if !self.edges.is_empty() {
15746 struct_ser.serialize_field("edges", &self.edges)?;
15747 }
15748 if !self.dependent_table_ids.is_empty() {
15749 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
15750 }
15751 if self.table_ids_cnt != 0 {
15752 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
15753 }
15754 if let Some(v) = self.ctx.as_ref() {
15755 struct_ser.serialize_field("ctx", v)?;
15756 }
15757 if let Some(v) = self.parallelism.as_ref() {
15758 struct_ser.serialize_field("parallelism", v)?;
15759 }
15760 if let Some(v) = self.backfill_parallelism.as_ref() {
15761 struct_ser.serialize_field("backfillParallelism", v)?;
15762 }
15763 if !self.adaptive_parallelism_strategy.is_empty() {
15764 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
15765 }
15766 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
15767 struct_ser.serialize_field("backfillAdaptiveParallelismStrategy", &self.backfill_adaptive_parallelism_strategy)?;
15768 }
15769 if self.max_parallelism != 0 {
15770 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
15771 }
15772 if let Some(v) = self.backfill_order.as_ref() {
15773 struct_ser.serialize_field("backfillOrder", v)?;
15774 }
15775 struct_ser.end()
15776 }
15777}
15778impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
15779 #[allow(deprecated)]
15780 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15781 where
15782 D: serde::Deserializer<'de>,
15783 {
15784 const FIELDS: &[&str] = &[
15785 "fragments",
15786 "edges",
15787 "dependent_table_ids",
15788 "dependentTableIds",
15789 "table_ids_cnt",
15790 "tableIdsCnt",
15791 "ctx",
15792 "parallelism",
15793 "backfill_parallelism",
15794 "backfillParallelism",
15795 "adaptive_parallelism_strategy",
15796 "adaptiveParallelismStrategy",
15797 "backfill_adaptive_parallelism_strategy",
15798 "backfillAdaptiveParallelismStrategy",
15799 "max_parallelism",
15800 "maxParallelism",
15801 "backfill_order",
15802 "backfillOrder",
15803 ];
15804
15805 #[allow(clippy::enum_variant_names)]
15806 enum GeneratedField {
15807 Fragments,
15808 Edges,
15809 DependentTableIds,
15810 TableIdsCnt,
15811 Ctx,
15812 Parallelism,
15813 BackfillParallelism,
15814 AdaptiveParallelismStrategy,
15815 BackfillAdaptiveParallelismStrategy,
15816 MaxParallelism,
15817 BackfillOrder,
15818 }
15819 impl<'de> serde::Deserialize<'de> for GeneratedField {
15820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15821 where
15822 D: serde::Deserializer<'de>,
15823 {
15824 struct GeneratedVisitor;
15825
15826 impl serde::de::Visitor<'_> for GeneratedVisitor {
15827 type Value = GeneratedField;
15828
15829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15830 write!(formatter, "expected one of: {:?}", &FIELDS)
15831 }
15832
15833 #[allow(unused_variables)]
15834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15835 where
15836 E: serde::de::Error,
15837 {
15838 match value {
15839 "fragments" => Ok(GeneratedField::Fragments),
15840 "edges" => Ok(GeneratedField::Edges),
15841 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
15842 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
15843 "ctx" => Ok(GeneratedField::Ctx),
15844 "parallelism" => Ok(GeneratedField::Parallelism),
15845 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
15846 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15847 "backfillAdaptiveParallelismStrategy" | "backfill_adaptive_parallelism_strategy" => Ok(GeneratedField::BackfillAdaptiveParallelismStrategy),
15848 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15849 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
15850 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15851 }
15852 }
15853 }
15854 deserializer.deserialize_identifier(GeneratedVisitor)
15855 }
15856 }
15857 struct GeneratedVisitor;
15858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15859 type Value = StreamFragmentGraph;
15860
15861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15862 formatter.write_str("struct stream_plan.StreamFragmentGraph")
15863 }
15864
15865 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
15866 where
15867 V: serde::de::MapAccess<'de>,
15868 {
15869 let mut fragments__ = None;
15870 let mut edges__ = None;
15871 let mut dependent_table_ids__ = None;
15872 let mut table_ids_cnt__ = None;
15873 let mut ctx__ = None;
15874 let mut parallelism__ = None;
15875 let mut backfill_parallelism__ = None;
15876 let mut adaptive_parallelism_strategy__ = None;
15877 let mut backfill_adaptive_parallelism_strategy__ = None;
15878 let mut max_parallelism__ = None;
15879 let mut backfill_order__ = None;
15880 while let Some(k) = map_.next_key()? {
15881 match k {
15882 GeneratedField::Fragments => {
15883 if fragments__.is_some() {
15884 return Err(serde::de::Error::duplicate_field("fragments"));
15885 }
15886 fragments__ = Some(
15887 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15888 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15889 );
15890 }
15891 GeneratedField::Edges => {
15892 if edges__.is_some() {
15893 return Err(serde::de::Error::duplicate_field("edges"));
15894 }
15895 edges__ = Some(map_.next_value()?);
15896 }
15897 GeneratedField::DependentTableIds => {
15898 if dependent_table_ids__.is_some() {
15899 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
15900 }
15901 dependent_table_ids__ =
15902 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15903 .into_iter().map(|x| x.0).collect())
15904 ;
15905 }
15906 GeneratedField::TableIdsCnt => {
15907 if table_ids_cnt__.is_some() {
15908 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
15909 }
15910 table_ids_cnt__ =
15911 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15912 ;
15913 }
15914 GeneratedField::Ctx => {
15915 if ctx__.is_some() {
15916 return Err(serde::de::Error::duplicate_field("ctx"));
15917 }
15918 ctx__ = map_.next_value()?;
15919 }
15920 GeneratedField::Parallelism => {
15921 if parallelism__.is_some() {
15922 return Err(serde::de::Error::duplicate_field("parallelism"));
15923 }
15924 parallelism__ = map_.next_value()?;
15925 }
15926 GeneratedField::BackfillParallelism => {
15927 if backfill_parallelism__.is_some() {
15928 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
15929 }
15930 backfill_parallelism__ = map_.next_value()?;
15931 }
15932 GeneratedField::AdaptiveParallelismStrategy => {
15933 if adaptive_parallelism_strategy__.is_some() {
15934 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15935 }
15936 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
15937 }
15938 GeneratedField::BackfillAdaptiveParallelismStrategy => {
15939 if backfill_adaptive_parallelism_strategy__.is_some() {
15940 return Err(serde::de::Error::duplicate_field("backfillAdaptiveParallelismStrategy"));
15941 }
15942 backfill_adaptive_parallelism_strategy__ = Some(map_.next_value()?);
15943 }
15944 GeneratedField::MaxParallelism => {
15945 if max_parallelism__.is_some() {
15946 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15947 }
15948 max_parallelism__ =
15949 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15950 ;
15951 }
15952 GeneratedField::BackfillOrder => {
15953 if backfill_order__.is_some() {
15954 return Err(serde::de::Error::duplicate_field("backfillOrder"));
15955 }
15956 backfill_order__ = map_.next_value()?;
15957 }
15958 }
15959 }
15960 Ok(StreamFragmentGraph {
15961 fragments: fragments__.unwrap_or_default(),
15962 edges: edges__.unwrap_or_default(),
15963 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
15964 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
15965 ctx: ctx__,
15966 parallelism: parallelism__,
15967 backfill_parallelism: backfill_parallelism__,
15968 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
15969 backfill_adaptive_parallelism_strategy: backfill_adaptive_parallelism_strategy__.unwrap_or_default(),
15970 max_parallelism: max_parallelism__.unwrap_or_default(),
15971 backfill_order: backfill_order__,
15972 })
15973 }
15974 }
15975 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
15976 }
15977}
15978impl serde::Serialize for stream_fragment_graph::Parallelism {
15979 #[allow(deprecated)]
15980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15981 where
15982 S: serde::Serializer,
15983 {
15984 use serde::ser::SerializeStruct;
15985 let mut len = 0;
15986 if self.parallelism != 0 {
15987 len += 1;
15988 }
15989 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
15990 if self.parallelism != 0 {
15991 #[allow(clippy::needless_borrow)]
15992 #[allow(clippy::needless_borrows_for_generic_args)]
15993 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
15994 }
15995 struct_ser.end()
15996 }
15997}
15998impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
15999 #[allow(deprecated)]
16000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16001 where
16002 D: serde::Deserializer<'de>,
16003 {
16004 const FIELDS: &[&str] = &[
16005 "parallelism",
16006 ];
16007
16008 #[allow(clippy::enum_variant_names)]
16009 enum GeneratedField {
16010 Parallelism,
16011 }
16012 impl<'de> serde::Deserialize<'de> for GeneratedField {
16013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16014 where
16015 D: serde::Deserializer<'de>,
16016 {
16017 struct GeneratedVisitor;
16018
16019 impl serde::de::Visitor<'_> for GeneratedVisitor {
16020 type Value = GeneratedField;
16021
16022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16023 write!(formatter, "expected one of: {:?}", &FIELDS)
16024 }
16025
16026 #[allow(unused_variables)]
16027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16028 where
16029 E: serde::de::Error,
16030 {
16031 match value {
16032 "parallelism" => Ok(GeneratedField::Parallelism),
16033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16034 }
16035 }
16036 }
16037 deserializer.deserialize_identifier(GeneratedVisitor)
16038 }
16039 }
16040 struct GeneratedVisitor;
16041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16042 type Value = stream_fragment_graph::Parallelism;
16043
16044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16045 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
16046 }
16047
16048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
16049 where
16050 V: serde::de::MapAccess<'de>,
16051 {
16052 let mut parallelism__ = None;
16053 while let Some(k) = map_.next_key()? {
16054 match k {
16055 GeneratedField::Parallelism => {
16056 if parallelism__.is_some() {
16057 return Err(serde::de::Error::duplicate_field("parallelism"));
16058 }
16059 parallelism__ =
16060 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16061 ;
16062 }
16063 }
16064 }
16065 Ok(stream_fragment_graph::Parallelism {
16066 parallelism: parallelism__.unwrap_or_default(),
16067 })
16068 }
16069 }
16070 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
16071 }
16072}
16073impl serde::Serialize for stream_fragment_graph::StreamFragment {
16074 #[allow(deprecated)]
16075 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16076 where
16077 S: serde::Serializer,
16078 {
16079 use serde::ser::SerializeStruct;
16080 let mut len = 0;
16081 if self.fragment_id != 0 {
16082 len += 1;
16083 }
16084 if self.node.is_some() {
16085 len += 1;
16086 }
16087 if self.fragment_type_mask != 0 {
16088 len += 1;
16089 }
16090 if self.requires_singleton {
16091 len += 1;
16092 }
16093 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
16094 if self.fragment_id != 0 {
16095 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
16096 }
16097 if let Some(v) = self.node.as_ref() {
16098 struct_ser.serialize_field("node", v)?;
16099 }
16100 if self.fragment_type_mask != 0 {
16101 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
16102 }
16103 if self.requires_singleton {
16104 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
16105 }
16106 struct_ser.end()
16107 }
16108}
16109impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
16110 #[allow(deprecated)]
16111 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16112 where
16113 D: serde::Deserializer<'de>,
16114 {
16115 const FIELDS: &[&str] = &[
16116 "fragment_id",
16117 "fragmentId",
16118 "node",
16119 "fragment_type_mask",
16120 "fragmentTypeMask",
16121 "requires_singleton",
16122 "requiresSingleton",
16123 ];
16124
16125 #[allow(clippy::enum_variant_names)]
16126 enum GeneratedField {
16127 FragmentId,
16128 Node,
16129 FragmentTypeMask,
16130 RequiresSingleton,
16131 }
16132 impl<'de> serde::Deserialize<'de> for GeneratedField {
16133 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16134 where
16135 D: serde::Deserializer<'de>,
16136 {
16137 struct GeneratedVisitor;
16138
16139 impl serde::de::Visitor<'_> for GeneratedVisitor {
16140 type Value = GeneratedField;
16141
16142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16143 write!(formatter, "expected one of: {:?}", &FIELDS)
16144 }
16145
16146 #[allow(unused_variables)]
16147 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16148 where
16149 E: serde::de::Error,
16150 {
16151 match value {
16152 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
16153 "node" => Ok(GeneratedField::Node),
16154 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
16155 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
16156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16157 }
16158 }
16159 }
16160 deserializer.deserialize_identifier(GeneratedVisitor)
16161 }
16162 }
16163 struct GeneratedVisitor;
16164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16165 type Value = stream_fragment_graph::StreamFragment;
16166
16167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16168 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
16169 }
16170
16171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
16172 where
16173 V: serde::de::MapAccess<'de>,
16174 {
16175 let mut fragment_id__ = None;
16176 let mut node__ = None;
16177 let mut fragment_type_mask__ = None;
16178 let mut requires_singleton__ = None;
16179 while let Some(k) = map_.next_key()? {
16180 match k {
16181 GeneratedField::FragmentId => {
16182 if fragment_id__.is_some() {
16183 return Err(serde::de::Error::duplicate_field("fragmentId"));
16184 }
16185 fragment_id__ =
16186 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16187 ;
16188 }
16189 GeneratedField::Node => {
16190 if node__.is_some() {
16191 return Err(serde::de::Error::duplicate_field("node"));
16192 }
16193 node__ = map_.next_value()?;
16194 }
16195 GeneratedField::FragmentTypeMask => {
16196 if fragment_type_mask__.is_some() {
16197 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
16198 }
16199 fragment_type_mask__ =
16200 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16201 ;
16202 }
16203 GeneratedField::RequiresSingleton => {
16204 if requires_singleton__.is_some() {
16205 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
16206 }
16207 requires_singleton__ = Some(map_.next_value()?);
16208 }
16209 }
16210 }
16211 Ok(stream_fragment_graph::StreamFragment {
16212 fragment_id: fragment_id__.unwrap_or_default(),
16213 node: node__,
16214 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
16215 requires_singleton: requires_singleton__.unwrap_or_default(),
16216 })
16217 }
16218 }
16219 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
16220 }
16221}
16222impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
16223 #[allow(deprecated)]
16224 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16225 where
16226 S: serde::Serializer,
16227 {
16228 use serde::ser::SerializeStruct;
16229 let mut len = 0;
16230 if self.dispatch_strategy.is_some() {
16231 len += 1;
16232 }
16233 if self.link_id != 0 {
16234 len += 1;
16235 }
16236 if self.upstream_id != 0 {
16237 len += 1;
16238 }
16239 if self.downstream_id != 0 {
16240 len += 1;
16241 }
16242 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
16243 if let Some(v) = self.dispatch_strategy.as_ref() {
16244 struct_ser.serialize_field("dispatchStrategy", v)?;
16245 }
16246 if self.link_id != 0 {
16247 #[allow(clippy::needless_borrow)]
16248 #[allow(clippy::needless_borrows_for_generic_args)]
16249 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
16250 }
16251 if self.upstream_id != 0 {
16252 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
16253 }
16254 if self.downstream_id != 0 {
16255 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
16256 }
16257 struct_ser.end()
16258 }
16259}
16260impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
16261 #[allow(deprecated)]
16262 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16263 where
16264 D: serde::Deserializer<'de>,
16265 {
16266 const FIELDS: &[&str] = &[
16267 "dispatch_strategy",
16268 "dispatchStrategy",
16269 "link_id",
16270 "linkId",
16271 "upstream_id",
16272 "upstreamId",
16273 "downstream_id",
16274 "downstreamId",
16275 ];
16276
16277 #[allow(clippy::enum_variant_names)]
16278 enum GeneratedField {
16279 DispatchStrategy,
16280 LinkId,
16281 UpstreamId,
16282 DownstreamId,
16283 }
16284 impl<'de> serde::Deserialize<'de> for GeneratedField {
16285 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16286 where
16287 D: serde::Deserializer<'de>,
16288 {
16289 struct GeneratedVisitor;
16290
16291 impl serde::de::Visitor<'_> for GeneratedVisitor {
16292 type Value = GeneratedField;
16293
16294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16295 write!(formatter, "expected one of: {:?}", &FIELDS)
16296 }
16297
16298 #[allow(unused_variables)]
16299 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16300 where
16301 E: serde::de::Error,
16302 {
16303 match value {
16304 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
16305 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
16306 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
16307 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
16308 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16309 }
16310 }
16311 }
16312 deserializer.deserialize_identifier(GeneratedVisitor)
16313 }
16314 }
16315 struct GeneratedVisitor;
16316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16317 type Value = stream_fragment_graph::StreamFragmentEdge;
16318
16319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16320 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
16321 }
16322
16323 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
16324 where
16325 V: serde::de::MapAccess<'de>,
16326 {
16327 let mut dispatch_strategy__ = None;
16328 let mut link_id__ = None;
16329 let mut upstream_id__ = None;
16330 let mut downstream_id__ = None;
16331 while let Some(k) = map_.next_key()? {
16332 match k {
16333 GeneratedField::DispatchStrategy => {
16334 if dispatch_strategy__.is_some() {
16335 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
16336 }
16337 dispatch_strategy__ = map_.next_value()?;
16338 }
16339 GeneratedField::LinkId => {
16340 if link_id__.is_some() {
16341 return Err(serde::de::Error::duplicate_field("linkId"));
16342 }
16343 link_id__ =
16344 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16345 ;
16346 }
16347 GeneratedField::UpstreamId => {
16348 if upstream_id__.is_some() {
16349 return Err(serde::de::Error::duplicate_field("upstreamId"));
16350 }
16351 upstream_id__ =
16352 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16353 ;
16354 }
16355 GeneratedField::DownstreamId => {
16356 if downstream_id__.is_some() {
16357 return Err(serde::de::Error::duplicate_field("downstreamId"));
16358 }
16359 downstream_id__ =
16360 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16361 ;
16362 }
16363 }
16364 }
16365 Ok(stream_fragment_graph::StreamFragmentEdge {
16366 dispatch_strategy: dispatch_strategy__,
16367 link_id: link_id__.unwrap_or_default(),
16368 upstream_id: upstream_id__.unwrap_or_default(),
16369 downstream_id: downstream_id__.unwrap_or_default(),
16370 })
16371 }
16372 }
16373 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
16374 }
16375}
16376impl serde::Serialize for StreamFsFetch {
16377 #[allow(deprecated)]
16378 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16379 where
16380 S: serde::Serializer,
16381 {
16382 use serde::ser::SerializeStruct;
16383 let mut len = 0;
16384 if self.source_id != 0 {
16385 len += 1;
16386 }
16387 if self.state_table.is_some() {
16388 len += 1;
16389 }
16390 if self.row_id_index.is_some() {
16391 len += 1;
16392 }
16393 if !self.columns.is_empty() {
16394 len += 1;
16395 }
16396 if !self.with_properties.is_empty() {
16397 len += 1;
16398 }
16399 if self.info.is_some() {
16400 len += 1;
16401 }
16402 if !self.source_name.is_empty() {
16403 len += 1;
16404 }
16405 if self.rate_limit.is_some() {
16406 len += 1;
16407 }
16408 if !self.secret_refs.is_empty() {
16409 len += 1;
16410 }
16411 if self.refresh_mode.is_some() {
16412 len += 1;
16413 }
16414 if self.associated_table_id.is_some() {
16415 len += 1;
16416 }
16417 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
16418 if self.source_id != 0 {
16419 struct_ser.serialize_field("sourceId", &self.source_id)?;
16420 }
16421 if let Some(v) = self.state_table.as_ref() {
16422 struct_ser.serialize_field("stateTable", v)?;
16423 }
16424 if let Some(v) = self.row_id_index.as_ref() {
16425 struct_ser.serialize_field("rowIdIndex", v)?;
16426 }
16427 if !self.columns.is_empty() {
16428 struct_ser.serialize_field("columns", &self.columns)?;
16429 }
16430 if !self.with_properties.is_empty() {
16431 struct_ser.serialize_field("withProperties", &self.with_properties)?;
16432 }
16433 if let Some(v) = self.info.as_ref() {
16434 struct_ser.serialize_field("info", v)?;
16435 }
16436 if !self.source_name.is_empty() {
16437 struct_ser.serialize_field("sourceName", &self.source_name)?;
16438 }
16439 if let Some(v) = self.rate_limit.as_ref() {
16440 struct_ser.serialize_field("rateLimit", v)?;
16441 }
16442 if !self.secret_refs.is_empty() {
16443 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
16444 }
16445 if let Some(v) = self.refresh_mode.as_ref() {
16446 struct_ser.serialize_field("refreshMode", v)?;
16447 }
16448 if let Some(v) = self.associated_table_id.as_ref() {
16449 struct_ser.serialize_field("associatedTableId", v)?;
16450 }
16451 struct_ser.end()
16452 }
16453}
16454impl<'de> serde::Deserialize<'de> for StreamFsFetch {
16455 #[allow(deprecated)]
16456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16457 where
16458 D: serde::Deserializer<'de>,
16459 {
16460 const FIELDS: &[&str] = &[
16461 "source_id",
16462 "sourceId",
16463 "state_table",
16464 "stateTable",
16465 "row_id_index",
16466 "rowIdIndex",
16467 "columns",
16468 "with_properties",
16469 "withProperties",
16470 "info",
16471 "source_name",
16472 "sourceName",
16473 "rate_limit",
16474 "rateLimit",
16475 "secret_refs",
16476 "secretRefs",
16477 "refresh_mode",
16478 "refreshMode",
16479 "associated_table_id",
16480 "associatedTableId",
16481 ];
16482
16483 #[allow(clippy::enum_variant_names)]
16484 enum GeneratedField {
16485 SourceId,
16486 StateTable,
16487 RowIdIndex,
16488 Columns,
16489 WithProperties,
16490 Info,
16491 SourceName,
16492 RateLimit,
16493 SecretRefs,
16494 RefreshMode,
16495 AssociatedTableId,
16496 }
16497 impl<'de> serde::Deserialize<'de> for GeneratedField {
16498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16499 where
16500 D: serde::Deserializer<'de>,
16501 {
16502 struct GeneratedVisitor;
16503
16504 impl serde::de::Visitor<'_> for GeneratedVisitor {
16505 type Value = GeneratedField;
16506
16507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16508 write!(formatter, "expected one of: {:?}", &FIELDS)
16509 }
16510
16511 #[allow(unused_variables)]
16512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16513 where
16514 E: serde::de::Error,
16515 {
16516 match value {
16517 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
16518 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
16519 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
16520 "columns" => Ok(GeneratedField::Columns),
16521 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
16522 "info" => Ok(GeneratedField::Info),
16523 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
16524 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16525 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
16526 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
16527 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
16528 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16529 }
16530 }
16531 }
16532 deserializer.deserialize_identifier(GeneratedVisitor)
16533 }
16534 }
16535 struct GeneratedVisitor;
16536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16537 type Value = StreamFsFetch;
16538
16539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16540 formatter.write_str("struct stream_plan.StreamFsFetch")
16541 }
16542
16543 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
16544 where
16545 V: serde::de::MapAccess<'de>,
16546 {
16547 let mut source_id__ = None;
16548 let mut state_table__ = None;
16549 let mut row_id_index__ = None;
16550 let mut columns__ = None;
16551 let mut with_properties__ = None;
16552 let mut info__ = None;
16553 let mut source_name__ = None;
16554 let mut rate_limit__ = None;
16555 let mut secret_refs__ = None;
16556 let mut refresh_mode__ = None;
16557 let mut associated_table_id__ = None;
16558 while let Some(k) = map_.next_key()? {
16559 match k {
16560 GeneratedField::SourceId => {
16561 if source_id__.is_some() {
16562 return Err(serde::de::Error::duplicate_field("sourceId"));
16563 }
16564 source_id__ =
16565 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16566 ;
16567 }
16568 GeneratedField::StateTable => {
16569 if state_table__.is_some() {
16570 return Err(serde::de::Error::duplicate_field("stateTable"));
16571 }
16572 state_table__ = map_.next_value()?;
16573 }
16574 GeneratedField::RowIdIndex => {
16575 if row_id_index__.is_some() {
16576 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
16577 }
16578 row_id_index__ =
16579 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16580 ;
16581 }
16582 GeneratedField::Columns => {
16583 if columns__.is_some() {
16584 return Err(serde::de::Error::duplicate_field("columns"));
16585 }
16586 columns__ = Some(map_.next_value()?);
16587 }
16588 GeneratedField::WithProperties => {
16589 if with_properties__.is_some() {
16590 return Err(serde::de::Error::duplicate_field("withProperties"));
16591 }
16592 with_properties__ = Some(
16593 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16594 );
16595 }
16596 GeneratedField::Info => {
16597 if info__.is_some() {
16598 return Err(serde::de::Error::duplicate_field("info"));
16599 }
16600 info__ = map_.next_value()?;
16601 }
16602 GeneratedField::SourceName => {
16603 if source_name__.is_some() {
16604 return Err(serde::de::Error::duplicate_field("sourceName"));
16605 }
16606 source_name__ = Some(map_.next_value()?);
16607 }
16608 GeneratedField::RateLimit => {
16609 if rate_limit__.is_some() {
16610 return Err(serde::de::Error::duplicate_field("rateLimit"));
16611 }
16612 rate_limit__ =
16613 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16614 ;
16615 }
16616 GeneratedField::SecretRefs => {
16617 if secret_refs__.is_some() {
16618 return Err(serde::de::Error::duplicate_field("secretRefs"));
16619 }
16620 secret_refs__ = Some(
16621 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16622 );
16623 }
16624 GeneratedField::RefreshMode => {
16625 if refresh_mode__.is_some() {
16626 return Err(serde::de::Error::duplicate_field("refreshMode"));
16627 }
16628 refresh_mode__ = map_.next_value()?;
16629 }
16630 GeneratedField::AssociatedTableId => {
16631 if associated_table_id__.is_some() {
16632 return Err(serde::de::Error::duplicate_field("associatedTableId"));
16633 }
16634 associated_table_id__ =
16635 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16636 ;
16637 }
16638 }
16639 }
16640 Ok(StreamFsFetch {
16641 source_id: source_id__.unwrap_or_default(),
16642 state_table: state_table__,
16643 row_id_index: row_id_index__,
16644 columns: columns__.unwrap_or_default(),
16645 with_properties: with_properties__.unwrap_or_default(),
16646 info: info__,
16647 source_name: source_name__.unwrap_or_default(),
16648 rate_limit: rate_limit__,
16649 secret_refs: secret_refs__.unwrap_or_default(),
16650 refresh_mode: refresh_mode__,
16651 associated_table_id: associated_table_id__,
16652 })
16653 }
16654 }
16655 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
16656 }
16657}
16658impl serde::Serialize for StreamFsFetchNode {
16659 #[allow(deprecated)]
16660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16661 where
16662 S: serde::Serializer,
16663 {
16664 use serde::ser::SerializeStruct;
16665 let mut len = 0;
16666 if self.node_inner.is_some() {
16667 len += 1;
16668 }
16669 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
16670 if let Some(v) = self.node_inner.as_ref() {
16671 struct_ser.serialize_field("nodeInner", v)?;
16672 }
16673 struct_ser.end()
16674 }
16675}
16676impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
16677 #[allow(deprecated)]
16678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16679 where
16680 D: serde::Deserializer<'de>,
16681 {
16682 const FIELDS: &[&str] = &[
16683 "node_inner",
16684 "nodeInner",
16685 ];
16686
16687 #[allow(clippy::enum_variant_names)]
16688 enum GeneratedField {
16689 NodeInner,
16690 }
16691 impl<'de> serde::Deserialize<'de> for GeneratedField {
16692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16693 where
16694 D: serde::Deserializer<'de>,
16695 {
16696 struct GeneratedVisitor;
16697
16698 impl serde::de::Visitor<'_> for GeneratedVisitor {
16699 type Value = GeneratedField;
16700
16701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16702 write!(formatter, "expected one of: {:?}", &FIELDS)
16703 }
16704
16705 #[allow(unused_variables)]
16706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16707 where
16708 E: serde::de::Error,
16709 {
16710 match value {
16711 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
16712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16713 }
16714 }
16715 }
16716 deserializer.deserialize_identifier(GeneratedVisitor)
16717 }
16718 }
16719 struct GeneratedVisitor;
16720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16721 type Value = StreamFsFetchNode;
16722
16723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16724 formatter.write_str("struct stream_plan.StreamFsFetchNode")
16725 }
16726
16727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
16728 where
16729 V: serde::de::MapAccess<'de>,
16730 {
16731 let mut node_inner__ = None;
16732 while let Some(k) = map_.next_key()? {
16733 match k {
16734 GeneratedField::NodeInner => {
16735 if node_inner__.is_some() {
16736 return Err(serde::de::Error::duplicate_field("nodeInner"));
16737 }
16738 node_inner__ = map_.next_value()?;
16739 }
16740 }
16741 }
16742 Ok(StreamFsFetchNode {
16743 node_inner: node_inner__,
16744 })
16745 }
16746 }
16747 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
16748 }
16749}
16750impl serde::Serialize for StreamMessage {
16751 #[allow(deprecated)]
16752 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16753 where
16754 S: serde::Serializer,
16755 {
16756 use serde::ser::SerializeStruct;
16757 let mut len = 0;
16758 if self.stream_message.is_some() {
16759 len += 1;
16760 }
16761 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
16762 if let Some(v) = self.stream_message.as_ref() {
16763 match v {
16764 stream_message::StreamMessage::StreamChunk(v) => {
16765 struct_ser.serialize_field("streamChunk", v)?;
16766 }
16767 stream_message::StreamMessage::Barrier(v) => {
16768 struct_ser.serialize_field("barrier", v)?;
16769 }
16770 stream_message::StreamMessage::Watermark(v) => {
16771 struct_ser.serialize_field("watermark", v)?;
16772 }
16773 }
16774 }
16775 struct_ser.end()
16776 }
16777}
16778impl<'de> serde::Deserialize<'de> for StreamMessage {
16779 #[allow(deprecated)]
16780 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16781 where
16782 D: serde::Deserializer<'de>,
16783 {
16784 const FIELDS: &[&str] = &[
16785 "stream_chunk",
16786 "streamChunk",
16787 "barrier",
16788 "watermark",
16789 ];
16790
16791 #[allow(clippy::enum_variant_names)]
16792 enum GeneratedField {
16793 StreamChunk,
16794 Barrier,
16795 Watermark,
16796 }
16797 impl<'de> serde::Deserialize<'de> for GeneratedField {
16798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16799 where
16800 D: serde::Deserializer<'de>,
16801 {
16802 struct GeneratedVisitor;
16803
16804 impl serde::de::Visitor<'_> for GeneratedVisitor {
16805 type Value = GeneratedField;
16806
16807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16808 write!(formatter, "expected one of: {:?}", &FIELDS)
16809 }
16810
16811 #[allow(unused_variables)]
16812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16813 where
16814 E: serde::de::Error,
16815 {
16816 match value {
16817 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
16818 "barrier" => Ok(GeneratedField::Barrier),
16819 "watermark" => Ok(GeneratedField::Watermark),
16820 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16821 }
16822 }
16823 }
16824 deserializer.deserialize_identifier(GeneratedVisitor)
16825 }
16826 }
16827 struct GeneratedVisitor;
16828 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16829 type Value = StreamMessage;
16830
16831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16832 formatter.write_str("struct stream_plan.StreamMessage")
16833 }
16834
16835 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
16836 where
16837 V: serde::de::MapAccess<'de>,
16838 {
16839 let mut stream_message__ = None;
16840 while let Some(k) = map_.next_key()? {
16841 match k {
16842 GeneratedField::StreamChunk => {
16843 if stream_message__.is_some() {
16844 return Err(serde::de::Error::duplicate_field("streamChunk"));
16845 }
16846 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
16847;
16848 }
16849 GeneratedField::Barrier => {
16850 if stream_message__.is_some() {
16851 return Err(serde::de::Error::duplicate_field("barrier"));
16852 }
16853 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
16854;
16855 }
16856 GeneratedField::Watermark => {
16857 if stream_message__.is_some() {
16858 return Err(serde::de::Error::duplicate_field("watermark"));
16859 }
16860 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
16861;
16862 }
16863 }
16864 }
16865 Ok(StreamMessage {
16866 stream_message: stream_message__,
16867 })
16868 }
16869 }
16870 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
16871 }
16872}
16873impl serde::Serialize for StreamMessageBatch {
16874 #[allow(deprecated)]
16875 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16876 where
16877 S: serde::Serializer,
16878 {
16879 use serde::ser::SerializeStruct;
16880 let mut len = 0;
16881 if self.stream_message_batch.is_some() {
16882 len += 1;
16883 }
16884 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
16885 if let Some(v) = self.stream_message_batch.as_ref() {
16886 match v {
16887 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
16888 struct_ser.serialize_field("streamChunk", v)?;
16889 }
16890 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
16891 struct_ser.serialize_field("barrierBatch", v)?;
16892 }
16893 stream_message_batch::StreamMessageBatch::Watermark(v) => {
16894 struct_ser.serialize_field("watermark", v)?;
16895 }
16896 }
16897 }
16898 struct_ser.end()
16899 }
16900}
16901impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
16902 #[allow(deprecated)]
16903 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16904 where
16905 D: serde::Deserializer<'de>,
16906 {
16907 const FIELDS: &[&str] = &[
16908 "stream_chunk",
16909 "streamChunk",
16910 "barrier_batch",
16911 "barrierBatch",
16912 "watermark",
16913 ];
16914
16915 #[allow(clippy::enum_variant_names)]
16916 enum GeneratedField {
16917 StreamChunk,
16918 BarrierBatch,
16919 Watermark,
16920 }
16921 impl<'de> serde::Deserialize<'de> for GeneratedField {
16922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16923 where
16924 D: serde::Deserializer<'de>,
16925 {
16926 struct GeneratedVisitor;
16927
16928 impl serde::de::Visitor<'_> for GeneratedVisitor {
16929 type Value = GeneratedField;
16930
16931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16932 write!(formatter, "expected one of: {:?}", &FIELDS)
16933 }
16934
16935 #[allow(unused_variables)]
16936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16937 where
16938 E: serde::de::Error,
16939 {
16940 match value {
16941 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
16942 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
16943 "watermark" => Ok(GeneratedField::Watermark),
16944 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16945 }
16946 }
16947 }
16948 deserializer.deserialize_identifier(GeneratedVisitor)
16949 }
16950 }
16951 struct GeneratedVisitor;
16952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16953 type Value = StreamMessageBatch;
16954
16955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16956 formatter.write_str("struct stream_plan.StreamMessageBatch")
16957 }
16958
16959 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
16960 where
16961 V: serde::de::MapAccess<'de>,
16962 {
16963 let mut stream_message_batch__ = None;
16964 while let Some(k) = map_.next_key()? {
16965 match k {
16966 GeneratedField::StreamChunk => {
16967 if stream_message_batch__.is_some() {
16968 return Err(serde::de::Error::duplicate_field("streamChunk"));
16969 }
16970 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
16971;
16972 }
16973 GeneratedField::BarrierBatch => {
16974 if stream_message_batch__.is_some() {
16975 return Err(serde::de::Error::duplicate_field("barrierBatch"));
16976 }
16977 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
16978;
16979 }
16980 GeneratedField::Watermark => {
16981 if stream_message_batch__.is_some() {
16982 return Err(serde::de::Error::duplicate_field("watermark"));
16983 }
16984 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
16985;
16986 }
16987 }
16988 }
16989 Ok(StreamMessageBatch {
16990 stream_message_batch: stream_message_batch__,
16991 })
16992 }
16993 }
16994 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
16995 }
16996}
16997impl serde::Serialize for stream_message_batch::BarrierBatch {
16998 #[allow(deprecated)]
16999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17000 where
17001 S: serde::Serializer,
17002 {
17003 use serde::ser::SerializeStruct;
17004 let mut len = 0;
17005 if !self.barriers.is_empty() {
17006 len += 1;
17007 }
17008 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
17009 if !self.barriers.is_empty() {
17010 struct_ser.serialize_field("barriers", &self.barriers)?;
17011 }
17012 struct_ser.end()
17013 }
17014}
17015impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
17016 #[allow(deprecated)]
17017 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17018 where
17019 D: serde::Deserializer<'de>,
17020 {
17021 const FIELDS: &[&str] = &[
17022 "barriers",
17023 ];
17024
17025 #[allow(clippy::enum_variant_names)]
17026 enum GeneratedField {
17027 Barriers,
17028 }
17029 impl<'de> serde::Deserialize<'de> for GeneratedField {
17030 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17031 where
17032 D: serde::Deserializer<'de>,
17033 {
17034 struct GeneratedVisitor;
17035
17036 impl serde::de::Visitor<'_> for GeneratedVisitor {
17037 type Value = GeneratedField;
17038
17039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17040 write!(formatter, "expected one of: {:?}", &FIELDS)
17041 }
17042
17043 #[allow(unused_variables)]
17044 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17045 where
17046 E: serde::de::Error,
17047 {
17048 match value {
17049 "barriers" => Ok(GeneratedField::Barriers),
17050 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17051 }
17052 }
17053 }
17054 deserializer.deserialize_identifier(GeneratedVisitor)
17055 }
17056 }
17057 struct GeneratedVisitor;
17058 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17059 type Value = stream_message_batch::BarrierBatch;
17060
17061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17062 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
17063 }
17064
17065 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
17066 where
17067 V: serde::de::MapAccess<'de>,
17068 {
17069 let mut barriers__ = None;
17070 while let Some(k) = map_.next_key()? {
17071 match k {
17072 GeneratedField::Barriers => {
17073 if barriers__.is_some() {
17074 return Err(serde::de::Error::duplicate_field("barriers"));
17075 }
17076 barriers__ = Some(map_.next_value()?);
17077 }
17078 }
17079 }
17080 Ok(stream_message_batch::BarrierBatch {
17081 barriers: barriers__.unwrap_or_default(),
17082 })
17083 }
17084 }
17085 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
17086 }
17087}
17088impl serde::Serialize for StreamNode {
17089 #[allow(deprecated)]
17090 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17091 where
17092 S: serde::Serializer,
17093 {
17094 use serde::ser::SerializeStruct;
17095 let mut len = 0;
17096 if self.operator_id != 0 {
17097 len += 1;
17098 }
17099 if !self.input.is_empty() {
17100 len += 1;
17101 }
17102 if !self.stream_key.is_empty() {
17103 len += 1;
17104 }
17105 if self.stream_kind != 0 {
17106 len += 1;
17107 }
17108 if !self.identity.is_empty() {
17109 len += 1;
17110 }
17111 if !self.fields.is_empty() {
17112 len += 1;
17113 }
17114 if self.node_body.is_some() {
17115 len += 1;
17116 }
17117 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
17118 if self.operator_id != 0 {
17119 #[allow(clippy::needless_borrow)]
17120 #[allow(clippy::needless_borrows_for_generic_args)]
17121 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
17122 }
17123 if !self.input.is_empty() {
17124 struct_ser.serialize_field("input", &self.input)?;
17125 }
17126 if !self.stream_key.is_empty() {
17127 struct_ser.serialize_field("streamKey", &self.stream_key)?;
17128 }
17129 if self.stream_kind != 0 {
17130 let v = stream_node::StreamKind::try_from(self.stream_kind)
17131 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
17132 struct_ser.serialize_field("streamKind", &v)?;
17133 }
17134 if !self.identity.is_empty() {
17135 struct_ser.serialize_field("identity", &self.identity)?;
17136 }
17137 if !self.fields.is_empty() {
17138 struct_ser.serialize_field("fields", &self.fields)?;
17139 }
17140 if let Some(v) = self.node_body.as_ref() {
17141 match v {
17142 stream_node::NodeBody::Source(v) => {
17143 struct_ser.serialize_field("source", v)?;
17144 }
17145 stream_node::NodeBody::Project(v) => {
17146 struct_ser.serialize_field("project", v)?;
17147 }
17148 stream_node::NodeBody::Filter(v) => {
17149 struct_ser.serialize_field("filter", v)?;
17150 }
17151 stream_node::NodeBody::Materialize(v) => {
17152 struct_ser.serialize_field("materialize", v)?;
17153 }
17154 stream_node::NodeBody::StatelessSimpleAgg(v) => {
17155 struct_ser.serialize_field("statelessSimpleAgg", v)?;
17156 }
17157 stream_node::NodeBody::SimpleAgg(v) => {
17158 struct_ser.serialize_field("simpleAgg", v)?;
17159 }
17160 stream_node::NodeBody::HashAgg(v) => {
17161 struct_ser.serialize_field("hashAgg", v)?;
17162 }
17163 stream_node::NodeBody::AppendOnlyTopN(v) => {
17164 struct_ser.serialize_field("appendOnlyTopN", v)?;
17165 }
17166 stream_node::NodeBody::HashJoin(v) => {
17167 struct_ser.serialize_field("hashJoin", v)?;
17168 }
17169 stream_node::NodeBody::TopN(v) => {
17170 struct_ser.serialize_field("topN", v)?;
17171 }
17172 stream_node::NodeBody::HopWindow(v) => {
17173 struct_ser.serialize_field("hopWindow", v)?;
17174 }
17175 stream_node::NodeBody::Merge(v) => {
17176 struct_ser.serialize_field("merge", v)?;
17177 }
17178 stream_node::NodeBody::Exchange(v) => {
17179 struct_ser.serialize_field("exchange", v)?;
17180 }
17181 stream_node::NodeBody::StreamScan(v) => {
17182 struct_ser.serialize_field("streamScan", v)?;
17183 }
17184 stream_node::NodeBody::BatchPlan(v) => {
17185 struct_ser.serialize_field("batchPlan", v)?;
17186 }
17187 stream_node::NodeBody::Lookup(v) => {
17188 struct_ser.serialize_field("lookup", v)?;
17189 }
17190 stream_node::NodeBody::Arrange(v) => {
17191 struct_ser.serialize_field("arrange", v)?;
17192 }
17193 stream_node::NodeBody::LookupUnion(v) => {
17194 struct_ser.serialize_field("lookupUnion", v)?;
17195 }
17196 stream_node::NodeBody::Union(v) => {
17197 struct_ser.serialize_field("union", v)?;
17198 }
17199 stream_node::NodeBody::DeltaIndexJoin(v) => {
17200 struct_ser.serialize_field("deltaIndexJoin", v)?;
17201 }
17202 stream_node::NodeBody::Sink(v) => {
17203 struct_ser.serialize_field("sink", v)?;
17204 }
17205 stream_node::NodeBody::Expand(v) => {
17206 struct_ser.serialize_field("expand", v)?;
17207 }
17208 stream_node::NodeBody::DynamicFilter(v) => {
17209 struct_ser.serialize_field("dynamicFilter", v)?;
17210 }
17211 stream_node::NodeBody::ProjectSet(v) => {
17212 struct_ser.serialize_field("projectSet", v)?;
17213 }
17214 stream_node::NodeBody::GroupTopN(v) => {
17215 struct_ser.serialize_field("groupTopN", v)?;
17216 }
17217 stream_node::NodeBody::Sort(v) => {
17218 struct_ser.serialize_field("sort", v)?;
17219 }
17220 stream_node::NodeBody::WatermarkFilter(v) => {
17221 struct_ser.serialize_field("watermarkFilter", v)?;
17222 }
17223 stream_node::NodeBody::Dml(v) => {
17224 struct_ser.serialize_field("dml", v)?;
17225 }
17226 stream_node::NodeBody::RowIdGen(v) => {
17227 struct_ser.serialize_field("rowIdGen", v)?;
17228 }
17229 stream_node::NodeBody::Now(v) => {
17230 struct_ser.serialize_field("now", v)?;
17231 }
17232 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
17233 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
17234 }
17235 stream_node::NodeBody::TemporalJoin(v) => {
17236 struct_ser.serialize_field("temporalJoin", v)?;
17237 }
17238 stream_node::NodeBody::BarrierRecv(v) => {
17239 struct_ser.serialize_field("barrierRecv", v)?;
17240 }
17241 stream_node::NodeBody::Values(v) => {
17242 struct_ser.serialize_field("values", v)?;
17243 }
17244 stream_node::NodeBody::AppendOnlyDedup(v) => {
17245 struct_ser.serialize_field("appendOnlyDedup", v)?;
17246 }
17247 stream_node::NodeBody::NoOp(v) => {
17248 struct_ser.serialize_field("noOp", v)?;
17249 }
17250 stream_node::NodeBody::EowcOverWindow(v) => {
17251 struct_ser.serialize_field("eowcOverWindow", v)?;
17252 }
17253 stream_node::NodeBody::OverWindow(v) => {
17254 struct_ser.serialize_field("overWindow", v)?;
17255 }
17256 stream_node::NodeBody::StreamFsFetch(v) => {
17257 struct_ser.serialize_field("streamFsFetch", v)?;
17258 }
17259 stream_node::NodeBody::StreamCdcScan(v) => {
17260 struct_ser.serialize_field("streamCdcScan", v)?;
17261 }
17262 stream_node::NodeBody::CdcFilter(v) => {
17263 struct_ser.serialize_field("cdcFilter", v)?;
17264 }
17265 stream_node::NodeBody::SourceBackfill(v) => {
17266 struct_ser.serialize_field("sourceBackfill", v)?;
17267 }
17268 stream_node::NodeBody::Changelog(v) => {
17269 struct_ser.serialize_field("changelog", v)?;
17270 }
17271 stream_node::NodeBody::LocalApproxPercentile(v) => {
17272 struct_ser.serialize_field("localApproxPercentile", v)?;
17273 }
17274 stream_node::NodeBody::GlobalApproxPercentile(v) => {
17275 struct_ser.serialize_field("globalApproxPercentile", v)?;
17276 }
17277 stream_node::NodeBody::RowMerge(v) => {
17278 struct_ser.serialize_field("rowMerge", v)?;
17279 }
17280 stream_node::NodeBody::AsOfJoin(v) => {
17281 struct_ser.serialize_field("asOfJoin", v)?;
17282 }
17283 stream_node::NodeBody::SyncLogStore(v) => {
17284 struct_ser.serialize_field("syncLogStore", v)?;
17285 }
17286 stream_node::NodeBody::MaterializedExprs(v) => {
17287 struct_ser.serialize_field("materializedExprs", v)?;
17288 }
17289 stream_node::NodeBody::VectorIndexWrite(v) => {
17290 struct_ser.serialize_field("vectorIndexWrite", v)?;
17291 }
17292 stream_node::NodeBody::UpstreamSinkUnion(v) => {
17293 struct_ser.serialize_field("upstreamSinkUnion", v)?;
17294 }
17295 stream_node::NodeBody::LocalityProvider(v) => {
17296 struct_ser.serialize_field("localityProvider", v)?;
17297 }
17298 stream_node::NodeBody::EowcGapFill(v) => {
17299 struct_ser.serialize_field("eowcGapFill", v)?;
17300 }
17301 stream_node::NodeBody::GapFill(v) => {
17302 struct_ser.serialize_field("gapFill", v)?;
17303 }
17304 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
17305 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
17306 }
17307 stream_node::NodeBody::IcebergWithPkIndexWriter(v) => {
17308 struct_ser.serialize_field("icebergWithPkIndexWriter", v)?;
17309 }
17310 stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger(v) => {
17311 struct_ser.serialize_field("icebergWithPkIndexPositionDeleteMerger", v)?;
17312 }
17313 stream_node::NodeBody::MatchRecognize(v) => {
17314 struct_ser.serialize_field("matchRecognize", v)?;
17315 }
17316 stream_node::NodeBody::CompactionResolver(v) => {
17317 struct_ser.serialize_field("compactionResolver", v)?;
17318 }
17319 }
17320 }
17321 struct_ser.end()
17322 }
17323}
17324impl<'de> serde::Deserialize<'de> for StreamNode {
17325 #[allow(deprecated)]
17326 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17327 where
17328 D: serde::Deserializer<'de>,
17329 {
17330 const FIELDS: &[&str] = &[
17331 "operator_id",
17332 "operatorId",
17333 "input",
17334 "stream_key",
17335 "streamKey",
17336 "stream_kind",
17337 "streamKind",
17338 "identity",
17339 "fields",
17340 "source",
17341 "project",
17342 "filter",
17343 "materialize",
17344 "stateless_simple_agg",
17345 "statelessSimpleAgg",
17346 "simple_agg",
17347 "simpleAgg",
17348 "hash_agg",
17349 "hashAgg",
17350 "append_only_top_n",
17351 "appendOnlyTopN",
17352 "hash_join",
17353 "hashJoin",
17354 "top_n",
17355 "topN",
17356 "hop_window",
17357 "hopWindow",
17358 "merge",
17359 "exchange",
17360 "stream_scan",
17361 "streamScan",
17362 "batch_plan",
17363 "batchPlan",
17364 "lookup",
17365 "arrange",
17366 "lookup_union",
17367 "lookupUnion",
17368 "union",
17369 "delta_index_join",
17370 "deltaIndexJoin",
17371 "sink",
17372 "expand",
17373 "dynamic_filter",
17374 "dynamicFilter",
17375 "project_set",
17376 "projectSet",
17377 "group_top_n",
17378 "groupTopN",
17379 "sort",
17380 "watermark_filter",
17381 "watermarkFilter",
17382 "dml",
17383 "row_id_gen",
17384 "rowIdGen",
17385 "now",
17386 "append_only_group_top_n",
17387 "appendOnlyGroupTopN",
17388 "temporal_join",
17389 "temporalJoin",
17390 "barrier_recv",
17391 "barrierRecv",
17392 "values",
17393 "append_only_dedup",
17394 "appendOnlyDedup",
17395 "no_op",
17396 "noOp",
17397 "eowc_over_window",
17398 "eowcOverWindow",
17399 "over_window",
17400 "overWindow",
17401 "stream_fs_fetch",
17402 "streamFsFetch",
17403 "stream_cdc_scan",
17404 "streamCdcScan",
17405 "cdc_filter",
17406 "cdcFilter",
17407 "source_backfill",
17408 "sourceBackfill",
17409 "changelog",
17410 "local_approx_percentile",
17411 "localApproxPercentile",
17412 "global_approx_percentile",
17413 "globalApproxPercentile",
17414 "row_merge",
17415 "rowMerge",
17416 "as_of_join",
17417 "asOfJoin",
17418 "sync_log_store",
17419 "syncLogStore",
17420 "materialized_exprs",
17421 "materializedExprs",
17422 "vector_index_write",
17423 "vectorIndexWrite",
17424 "upstream_sink_union",
17425 "upstreamSinkUnion",
17426 "locality_provider",
17427 "localityProvider",
17428 "eowc_gap_fill",
17429 "eowcGapFill",
17430 "gap_fill",
17431 "gapFill",
17432 "vector_index_lookup_join",
17433 "vectorIndexLookupJoin",
17434 "iceberg_with_pk_index_writer",
17435 "icebergWithPkIndexWriter",
17436 "iceberg_with_pk_index_position_delete_merger",
17437 "icebergWithPkIndexPositionDeleteMerger",
17438 "match_recognize",
17439 "matchRecognize",
17440 "compaction_resolver",
17441 "compactionResolver",
17442 ];
17443
17444 #[allow(clippy::enum_variant_names)]
17445 enum GeneratedField {
17446 OperatorId,
17447 Input,
17448 StreamKey,
17449 StreamKind,
17450 Identity,
17451 Fields,
17452 Source,
17453 Project,
17454 Filter,
17455 Materialize,
17456 StatelessSimpleAgg,
17457 SimpleAgg,
17458 HashAgg,
17459 AppendOnlyTopN,
17460 HashJoin,
17461 TopN,
17462 HopWindow,
17463 Merge,
17464 Exchange,
17465 StreamScan,
17466 BatchPlan,
17467 Lookup,
17468 Arrange,
17469 LookupUnion,
17470 Union,
17471 DeltaIndexJoin,
17472 Sink,
17473 Expand,
17474 DynamicFilter,
17475 ProjectSet,
17476 GroupTopN,
17477 Sort,
17478 WatermarkFilter,
17479 Dml,
17480 RowIdGen,
17481 Now,
17482 AppendOnlyGroupTopN,
17483 TemporalJoin,
17484 BarrierRecv,
17485 Values,
17486 AppendOnlyDedup,
17487 NoOp,
17488 EowcOverWindow,
17489 OverWindow,
17490 StreamFsFetch,
17491 StreamCdcScan,
17492 CdcFilter,
17493 SourceBackfill,
17494 Changelog,
17495 LocalApproxPercentile,
17496 GlobalApproxPercentile,
17497 RowMerge,
17498 AsOfJoin,
17499 SyncLogStore,
17500 MaterializedExprs,
17501 VectorIndexWrite,
17502 UpstreamSinkUnion,
17503 LocalityProvider,
17504 EowcGapFill,
17505 GapFill,
17506 VectorIndexLookupJoin,
17507 IcebergWithPkIndexWriter,
17508 IcebergWithPkIndexPositionDeleteMerger,
17509 MatchRecognize,
17510 CompactionResolver,
17511 }
17512 impl<'de> serde::Deserialize<'de> for GeneratedField {
17513 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17514 where
17515 D: serde::Deserializer<'de>,
17516 {
17517 struct GeneratedVisitor;
17518
17519 impl serde::de::Visitor<'_> for GeneratedVisitor {
17520 type Value = GeneratedField;
17521
17522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17523 write!(formatter, "expected one of: {:?}", &FIELDS)
17524 }
17525
17526 #[allow(unused_variables)]
17527 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17528 where
17529 E: serde::de::Error,
17530 {
17531 match value {
17532 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
17533 "input" => Ok(GeneratedField::Input),
17534 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
17535 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
17536 "identity" => Ok(GeneratedField::Identity),
17537 "fields" => Ok(GeneratedField::Fields),
17538 "source" => Ok(GeneratedField::Source),
17539 "project" => Ok(GeneratedField::Project),
17540 "filter" => Ok(GeneratedField::Filter),
17541 "materialize" => Ok(GeneratedField::Materialize),
17542 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
17543 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
17544 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
17545 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
17546 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
17547 "topN" | "top_n" => Ok(GeneratedField::TopN),
17548 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
17549 "merge" => Ok(GeneratedField::Merge),
17550 "exchange" => Ok(GeneratedField::Exchange),
17551 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
17552 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
17553 "lookup" => Ok(GeneratedField::Lookup),
17554 "arrange" => Ok(GeneratedField::Arrange),
17555 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
17556 "union" => Ok(GeneratedField::Union),
17557 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
17558 "sink" => Ok(GeneratedField::Sink),
17559 "expand" => Ok(GeneratedField::Expand),
17560 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
17561 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
17562 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
17563 "sort" => Ok(GeneratedField::Sort),
17564 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
17565 "dml" => Ok(GeneratedField::Dml),
17566 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
17567 "now" => Ok(GeneratedField::Now),
17568 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
17569 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
17570 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
17571 "values" => Ok(GeneratedField::Values),
17572 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
17573 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
17574 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
17575 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
17576 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
17577 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
17578 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
17579 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
17580 "changelog" => Ok(GeneratedField::Changelog),
17581 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
17582 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
17583 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
17584 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
17585 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
17586 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
17587 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
17588 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
17589 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
17590 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
17591 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
17592 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
17593 "icebergWithPkIndexWriter" | "iceberg_with_pk_index_writer" => Ok(GeneratedField::IcebergWithPkIndexWriter),
17594 "icebergWithPkIndexPositionDeleteMerger" | "iceberg_with_pk_index_position_delete_merger" => Ok(GeneratedField::IcebergWithPkIndexPositionDeleteMerger),
17595 "matchRecognize" | "match_recognize" => Ok(GeneratedField::MatchRecognize),
17596 "compactionResolver" | "compaction_resolver" => Ok(GeneratedField::CompactionResolver),
17597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17598 }
17599 }
17600 }
17601 deserializer.deserialize_identifier(GeneratedVisitor)
17602 }
17603 }
17604 struct GeneratedVisitor;
17605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17606 type Value = StreamNode;
17607
17608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17609 formatter.write_str("struct stream_plan.StreamNode")
17610 }
17611
17612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
17613 where
17614 V: serde::de::MapAccess<'de>,
17615 {
17616 let mut operator_id__ = None;
17617 let mut input__ = None;
17618 let mut stream_key__ = None;
17619 let mut stream_kind__ = None;
17620 let mut identity__ = None;
17621 let mut fields__ = None;
17622 let mut node_body__ = None;
17623 while let Some(k) = map_.next_key()? {
17624 match k {
17625 GeneratedField::OperatorId => {
17626 if operator_id__.is_some() {
17627 return Err(serde::de::Error::duplicate_field("operatorId"));
17628 }
17629 operator_id__ =
17630 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17631 ;
17632 }
17633 GeneratedField::Input => {
17634 if input__.is_some() {
17635 return Err(serde::de::Error::duplicate_field("input"));
17636 }
17637 input__ = Some(map_.next_value()?);
17638 }
17639 GeneratedField::StreamKey => {
17640 if stream_key__.is_some() {
17641 return Err(serde::de::Error::duplicate_field("streamKey"));
17642 }
17643 stream_key__ =
17644 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17645 .into_iter().map(|x| x.0).collect())
17646 ;
17647 }
17648 GeneratedField::StreamKind => {
17649 if stream_kind__.is_some() {
17650 return Err(serde::de::Error::duplicate_field("streamKind"));
17651 }
17652 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
17653 }
17654 GeneratedField::Identity => {
17655 if identity__.is_some() {
17656 return Err(serde::de::Error::duplicate_field("identity"));
17657 }
17658 identity__ = Some(map_.next_value()?);
17659 }
17660 GeneratedField::Fields => {
17661 if fields__.is_some() {
17662 return Err(serde::de::Error::duplicate_field("fields"));
17663 }
17664 fields__ = Some(map_.next_value()?);
17665 }
17666 GeneratedField::Source => {
17667 if node_body__.is_some() {
17668 return Err(serde::de::Error::duplicate_field("source"));
17669 }
17670 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
17671;
17672 }
17673 GeneratedField::Project => {
17674 if node_body__.is_some() {
17675 return Err(serde::de::Error::duplicate_field("project"));
17676 }
17677 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
17678;
17679 }
17680 GeneratedField::Filter => {
17681 if node_body__.is_some() {
17682 return Err(serde::de::Error::duplicate_field("filter"));
17683 }
17684 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
17685;
17686 }
17687 GeneratedField::Materialize => {
17688 if node_body__.is_some() {
17689 return Err(serde::de::Error::duplicate_field("materialize"));
17690 }
17691 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
17692;
17693 }
17694 GeneratedField::StatelessSimpleAgg => {
17695 if node_body__.is_some() {
17696 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
17697 }
17698 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
17699;
17700 }
17701 GeneratedField::SimpleAgg => {
17702 if node_body__.is_some() {
17703 return Err(serde::de::Error::duplicate_field("simpleAgg"));
17704 }
17705 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
17706;
17707 }
17708 GeneratedField::HashAgg => {
17709 if node_body__.is_some() {
17710 return Err(serde::de::Error::duplicate_field("hashAgg"));
17711 }
17712 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
17713;
17714 }
17715 GeneratedField::AppendOnlyTopN => {
17716 if node_body__.is_some() {
17717 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
17718 }
17719 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
17720;
17721 }
17722 GeneratedField::HashJoin => {
17723 if node_body__.is_some() {
17724 return Err(serde::de::Error::duplicate_field("hashJoin"));
17725 }
17726 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
17727;
17728 }
17729 GeneratedField::TopN => {
17730 if node_body__.is_some() {
17731 return Err(serde::de::Error::duplicate_field("topN"));
17732 }
17733 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
17734;
17735 }
17736 GeneratedField::HopWindow => {
17737 if node_body__.is_some() {
17738 return Err(serde::de::Error::duplicate_field("hopWindow"));
17739 }
17740 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
17741;
17742 }
17743 GeneratedField::Merge => {
17744 if node_body__.is_some() {
17745 return Err(serde::de::Error::duplicate_field("merge"));
17746 }
17747 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
17748;
17749 }
17750 GeneratedField::Exchange => {
17751 if node_body__.is_some() {
17752 return Err(serde::de::Error::duplicate_field("exchange"));
17753 }
17754 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
17755;
17756 }
17757 GeneratedField::StreamScan => {
17758 if node_body__.is_some() {
17759 return Err(serde::de::Error::duplicate_field("streamScan"));
17760 }
17761 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
17762;
17763 }
17764 GeneratedField::BatchPlan => {
17765 if node_body__.is_some() {
17766 return Err(serde::de::Error::duplicate_field("batchPlan"));
17767 }
17768 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
17769;
17770 }
17771 GeneratedField::Lookup => {
17772 if node_body__.is_some() {
17773 return Err(serde::de::Error::duplicate_field("lookup"));
17774 }
17775 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
17776;
17777 }
17778 GeneratedField::Arrange => {
17779 if node_body__.is_some() {
17780 return Err(serde::de::Error::duplicate_field("arrange"));
17781 }
17782 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
17783;
17784 }
17785 GeneratedField::LookupUnion => {
17786 if node_body__.is_some() {
17787 return Err(serde::de::Error::duplicate_field("lookupUnion"));
17788 }
17789 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
17790;
17791 }
17792 GeneratedField::Union => {
17793 if node_body__.is_some() {
17794 return Err(serde::de::Error::duplicate_field("union"));
17795 }
17796 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
17797;
17798 }
17799 GeneratedField::DeltaIndexJoin => {
17800 if node_body__.is_some() {
17801 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
17802 }
17803 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
17804;
17805 }
17806 GeneratedField::Sink => {
17807 if node_body__.is_some() {
17808 return Err(serde::de::Error::duplicate_field("sink"));
17809 }
17810 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
17811;
17812 }
17813 GeneratedField::Expand => {
17814 if node_body__.is_some() {
17815 return Err(serde::de::Error::duplicate_field("expand"));
17816 }
17817 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
17818;
17819 }
17820 GeneratedField::DynamicFilter => {
17821 if node_body__.is_some() {
17822 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
17823 }
17824 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
17825;
17826 }
17827 GeneratedField::ProjectSet => {
17828 if node_body__.is_some() {
17829 return Err(serde::de::Error::duplicate_field("projectSet"));
17830 }
17831 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
17832;
17833 }
17834 GeneratedField::GroupTopN => {
17835 if node_body__.is_some() {
17836 return Err(serde::de::Error::duplicate_field("groupTopN"));
17837 }
17838 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
17839;
17840 }
17841 GeneratedField::Sort => {
17842 if node_body__.is_some() {
17843 return Err(serde::de::Error::duplicate_field("sort"));
17844 }
17845 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
17846;
17847 }
17848 GeneratedField::WatermarkFilter => {
17849 if node_body__.is_some() {
17850 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
17851 }
17852 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
17853;
17854 }
17855 GeneratedField::Dml => {
17856 if node_body__.is_some() {
17857 return Err(serde::de::Error::duplicate_field("dml"));
17858 }
17859 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
17860;
17861 }
17862 GeneratedField::RowIdGen => {
17863 if node_body__.is_some() {
17864 return Err(serde::de::Error::duplicate_field("rowIdGen"));
17865 }
17866 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
17867;
17868 }
17869 GeneratedField::Now => {
17870 if node_body__.is_some() {
17871 return Err(serde::de::Error::duplicate_field("now"));
17872 }
17873 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
17874;
17875 }
17876 GeneratedField::AppendOnlyGroupTopN => {
17877 if node_body__.is_some() {
17878 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
17879 }
17880 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
17881;
17882 }
17883 GeneratedField::TemporalJoin => {
17884 if node_body__.is_some() {
17885 return Err(serde::de::Error::duplicate_field("temporalJoin"));
17886 }
17887 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
17888;
17889 }
17890 GeneratedField::BarrierRecv => {
17891 if node_body__.is_some() {
17892 return Err(serde::de::Error::duplicate_field("barrierRecv"));
17893 }
17894 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
17895;
17896 }
17897 GeneratedField::Values => {
17898 if node_body__.is_some() {
17899 return Err(serde::de::Error::duplicate_field("values"));
17900 }
17901 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
17902;
17903 }
17904 GeneratedField::AppendOnlyDedup => {
17905 if node_body__.is_some() {
17906 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
17907 }
17908 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
17909;
17910 }
17911 GeneratedField::NoOp => {
17912 if node_body__.is_some() {
17913 return Err(serde::de::Error::duplicate_field("noOp"));
17914 }
17915 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
17916;
17917 }
17918 GeneratedField::EowcOverWindow => {
17919 if node_body__.is_some() {
17920 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
17921 }
17922 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
17923;
17924 }
17925 GeneratedField::OverWindow => {
17926 if node_body__.is_some() {
17927 return Err(serde::de::Error::duplicate_field("overWindow"));
17928 }
17929 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
17930;
17931 }
17932 GeneratedField::StreamFsFetch => {
17933 if node_body__.is_some() {
17934 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
17935 }
17936 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
17937;
17938 }
17939 GeneratedField::StreamCdcScan => {
17940 if node_body__.is_some() {
17941 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
17942 }
17943 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
17944;
17945 }
17946 GeneratedField::CdcFilter => {
17947 if node_body__.is_some() {
17948 return Err(serde::de::Error::duplicate_field("cdcFilter"));
17949 }
17950 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
17951;
17952 }
17953 GeneratedField::SourceBackfill => {
17954 if node_body__.is_some() {
17955 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
17956 }
17957 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
17958;
17959 }
17960 GeneratedField::Changelog => {
17961 if node_body__.is_some() {
17962 return Err(serde::de::Error::duplicate_field("changelog"));
17963 }
17964 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
17965;
17966 }
17967 GeneratedField::LocalApproxPercentile => {
17968 if node_body__.is_some() {
17969 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
17970 }
17971 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
17972;
17973 }
17974 GeneratedField::GlobalApproxPercentile => {
17975 if node_body__.is_some() {
17976 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
17977 }
17978 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
17979;
17980 }
17981 GeneratedField::RowMerge => {
17982 if node_body__.is_some() {
17983 return Err(serde::de::Error::duplicate_field("rowMerge"));
17984 }
17985 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
17986;
17987 }
17988 GeneratedField::AsOfJoin => {
17989 if node_body__.is_some() {
17990 return Err(serde::de::Error::duplicate_field("asOfJoin"));
17991 }
17992 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
17993;
17994 }
17995 GeneratedField::SyncLogStore => {
17996 if node_body__.is_some() {
17997 return Err(serde::de::Error::duplicate_field("syncLogStore"));
17998 }
17999 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
18000;
18001 }
18002 GeneratedField::MaterializedExprs => {
18003 if node_body__.is_some() {
18004 return Err(serde::de::Error::duplicate_field("materializedExprs"));
18005 }
18006 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
18007;
18008 }
18009 GeneratedField::VectorIndexWrite => {
18010 if node_body__.is_some() {
18011 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
18012 }
18013 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
18014;
18015 }
18016 GeneratedField::UpstreamSinkUnion => {
18017 if node_body__.is_some() {
18018 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
18019 }
18020 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
18021;
18022 }
18023 GeneratedField::LocalityProvider => {
18024 if node_body__.is_some() {
18025 return Err(serde::de::Error::duplicate_field("localityProvider"));
18026 }
18027 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
18028;
18029 }
18030 GeneratedField::EowcGapFill => {
18031 if node_body__.is_some() {
18032 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
18033 }
18034 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
18035;
18036 }
18037 GeneratedField::GapFill => {
18038 if node_body__.is_some() {
18039 return Err(serde::de::Error::duplicate_field("gapFill"));
18040 }
18041 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
18042;
18043 }
18044 GeneratedField::VectorIndexLookupJoin => {
18045 if node_body__.is_some() {
18046 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
18047 }
18048 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
18049;
18050 }
18051 GeneratedField::IcebergWithPkIndexWriter => {
18052 if node_body__.is_some() {
18053 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexWriter"));
18054 }
18055 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexWriter)
18056;
18057 }
18058 GeneratedField::IcebergWithPkIndexPositionDeleteMerger => {
18059 if node_body__.is_some() {
18060 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexPositionDeleteMerger"));
18061 }
18062 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger)
18063;
18064 }
18065 GeneratedField::MatchRecognize => {
18066 if node_body__.is_some() {
18067 return Err(serde::de::Error::duplicate_field("matchRecognize"));
18068 }
18069 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MatchRecognize)
18070;
18071 }
18072 GeneratedField::CompactionResolver => {
18073 if node_body__.is_some() {
18074 return Err(serde::de::Error::duplicate_field("compactionResolver"));
18075 }
18076 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CompactionResolver)
18077;
18078 }
18079 }
18080 }
18081 Ok(StreamNode {
18082 operator_id: operator_id__.unwrap_or_default(),
18083 input: input__.unwrap_or_default(),
18084 stream_key: stream_key__.unwrap_or_default(),
18085 stream_kind: stream_kind__.unwrap_or_default(),
18086 identity: identity__.unwrap_or_default(),
18087 fields: fields__.unwrap_or_default(),
18088 node_body: node_body__,
18089 })
18090 }
18091 }
18092 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
18093 }
18094}
18095impl serde::Serialize for stream_node::StreamKind {
18096 #[allow(deprecated)]
18097 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18098 where
18099 S: serde::Serializer,
18100 {
18101 let variant = match self {
18102 Self::Retract => "STREAM_KIND_RETRACT",
18103 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
18104 Self::Upsert => "STREAM_KIND_UPSERT",
18105 };
18106 serializer.serialize_str(variant)
18107 }
18108}
18109impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
18110 #[allow(deprecated)]
18111 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18112 where
18113 D: serde::Deserializer<'de>,
18114 {
18115 const FIELDS: &[&str] = &[
18116 "STREAM_KIND_RETRACT",
18117 "STREAM_KIND_APPEND_ONLY",
18118 "STREAM_KIND_UPSERT",
18119 ];
18120
18121 struct GeneratedVisitor;
18122
18123 impl serde::de::Visitor<'_> for GeneratedVisitor {
18124 type Value = stream_node::StreamKind;
18125
18126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18127 write!(formatter, "expected one of: {:?}", &FIELDS)
18128 }
18129
18130 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18131 where
18132 E: serde::de::Error,
18133 {
18134 i32::try_from(v)
18135 .ok()
18136 .and_then(|x| x.try_into().ok())
18137 .ok_or_else(|| {
18138 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18139 })
18140 }
18141
18142 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18143 where
18144 E: serde::de::Error,
18145 {
18146 i32::try_from(v)
18147 .ok()
18148 .and_then(|x| x.try_into().ok())
18149 .ok_or_else(|| {
18150 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18151 })
18152 }
18153
18154 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18155 where
18156 E: serde::de::Error,
18157 {
18158 match value {
18159 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
18160 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
18161 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
18162 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18163 }
18164 }
18165 }
18166 deserializer.deserialize_any(GeneratedVisitor)
18167 }
18168}
18169impl serde::Serialize for StreamScanNode {
18170 #[allow(deprecated)]
18171 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18172 where
18173 S: serde::Serializer,
18174 {
18175 use serde::ser::SerializeStruct;
18176 let mut len = 0;
18177 if self.table_id != 0 {
18178 len += 1;
18179 }
18180 if !self.upstream_column_ids.is_empty() {
18181 len += 1;
18182 }
18183 if !self.output_indices.is_empty() {
18184 len += 1;
18185 }
18186 if self.stream_scan_type != 0 {
18187 len += 1;
18188 }
18189 if self.state_table.is_some() {
18190 len += 1;
18191 }
18192 if self.table_desc.is_some() {
18193 len += 1;
18194 }
18195 if self.rate_limit.is_some() {
18196 len += 1;
18197 }
18198 if self.snapshot_read_barrier_interval != 0 {
18199 len += 1;
18200 }
18201 if self.arrangement_table.is_some() {
18202 len += 1;
18203 }
18204 if self.snapshot_backfill_epoch.is_some() {
18205 len += 1;
18206 }
18207 if self.pk_scan_range.is_some() {
18208 len += 1;
18209 }
18210 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
18211 if self.table_id != 0 {
18212 struct_ser.serialize_field("tableId", &self.table_id)?;
18213 }
18214 if !self.upstream_column_ids.is_empty() {
18215 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
18216 }
18217 if !self.output_indices.is_empty() {
18218 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
18219 }
18220 if self.stream_scan_type != 0 {
18221 let v = StreamScanType::try_from(self.stream_scan_type)
18222 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
18223 struct_ser.serialize_field("streamScanType", &v)?;
18224 }
18225 if let Some(v) = self.state_table.as_ref() {
18226 struct_ser.serialize_field("stateTable", v)?;
18227 }
18228 if let Some(v) = self.table_desc.as_ref() {
18229 struct_ser.serialize_field("tableDesc", v)?;
18230 }
18231 if let Some(v) = self.rate_limit.as_ref() {
18232 struct_ser.serialize_field("rateLimit", v)?;
18233 }
18234 if self.snapshot_read_barrier_interval != 0 {
18235 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
18236 }
18237 if let Some(v) = self.arrangement_table.as_ref() {
18238 struct_ser.serialize_field("arrangementTable", v)?;
18239 }
18240 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
18241 #[allow(clippy::needless_borrow)]
18242 #[allow(clippy::needless_borrows_for_generic_args)]
18243 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
18244 }
18245 if let Some(v) = self.pk_scan_range.as_ref() {
18246 struct_ser.serialize_field("pkScanRange", v)?;
18247 }
18248 struct_ser.end()
18249 }
18250}
18251impl<'de> serde::Deserialize<'de> for StreamScanNode {
18252 #[allow(deprecated)]
18253 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18254 where
18255 D: serde::Deserializer<'de>,
18256 {
18257 const FIELDS: &[&str] = &[
18258 "table_id",
18259 "tableId",
18260 "upstream_column_ids",
18261 "upstreamColumnIds",
18262 "output_indices",
18263 "outputIndices",
18264 "stream_scan_type",
18265 "streamScanType",
18266 "state_table",
18267 "stateTable",
18268 "table_desc",
18269 "tableDesc",
18270 "rate_limit",
18271 "rateLimit",
18272 "snapshot_read_barrier_interval",
18273 "snapshotReadBarrierInterval",
18274 "arrangement_table",
18275 "arrangementTable",
18276 "snapshot_backfill_epoch",
18277 "snapshotBackfillEpoch",
18278 "pk_scan_range",
18279 "pkScanRange",
18280 ];
18281
18282 #[allow(clippy::enum_variant_names)]
18283 enum GeneratedField {
18284 TableId,
18285 UpstreamColumnIds,
18286 OutputIndices,
18287 StreamScanType,
18288 StateTable,
18289 TableDesc,
18290 RateLimit,
18291 SnapshotReadBarrierInterval,
18292 ArrangementTable,
18293 SnapshotBackfillEpoch,
18294 PkScanRange,
18295 }
18296 impl<'de> serde::Deserialize<'de> for GeneratedField {
18297 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18298 where
18299 D: serde::Deserializer<'de>,
18300 {
18301 struct GeneratedVisitor;
18302
18303 impl serde::de::Visitor<'_> for GeneratedVisitor {
18304 type Value = GeneratedField;
18305
18306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18307 write!(formatter, "expected one of: {:?}", &FIELDS)
18308 }
18309
18310 #[allow(unused_variables)]
18311 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18312 where
18313 E: serde::de::Error,
18314 {
18315 match value {
18316 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18317 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
18318 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
18319 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
18320 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
18321 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
18322 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
18323 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
18324 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
18325 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
18326 "pkScanRange" | "pk_scan_range" => Ok(GeneratedField::PkScanRange),
18327 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18328 }
18329 }
18330 }
18331 deserializer.deserialize_identifier(GeneratedVisitor)
18332 }
18333 }
18334 struct GeneratedVisitor;
18335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18336 type Value = StreamScanNode;
18337
18338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18339 formatter.write_str("struct stream_plan.StreamScanNode")
18340 }
18341
18342 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
18343 where
18344 V: serde::de::MapAccess<'de>,
18345 {
18346 let mut table_id__ = None;
18347 let mut upstream_column_ids__ = None;
18348 let mut output_indices__ = None;
18349 let mut stream_scan_type__ = None;
18350 let mut state_table__ = None;
18351 let mut table_desc__ = None;
18352 let mut rate_limit__ = None;
18353 let mut snapshot_read_barrier_interval__ = None;
18354 let mut arrangement_table__ = None;
18355 let mut snapshot_backfill_epoch__ = None;
18356 let mut pk_scan_range__ = None;
18357 while let Some(k) = map_.next_key()? {
18358 match k {
18359 GeneratedField::TableId => {
18360 if table_id__.is_some() {
18361 return Err(serde::de::Error::duplicate_field("tableId"));
18362 }
18363 table_id__ =
18364 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18365 ;
18366 }
18367 GeneratedField::UpstreamColumnIds => {
18368 if upstream_column_ids__.is_some() {
18369 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
18370 }
18371 upstream_column_ids__ =
18372 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18373 .into_iter().map(|x| x.0).collect())
18374 ;
18375 }
18376 GeneratedField::OutputIndices => {
18377 if output_indices__.is_some() {
18378 return Err(serde::de::Error::duplicate_field("outputIndices"));
18379 }
18380 output_indices__ =
18381 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18382 .into_iter().map(|x| x.0).collect())
18383 ;
18384 }
18385 GeneratedField::StreamScanType => {
18386 if stream_scan_type__.is_some() {
18387 return Err(serde::de::Error::duplicate_field("streamScanType"));
18388 }
18389 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
18390 }
18391 GeneratedField::StateTable => {
18392 if state_table__.is_some() {
18393 return Err(serde::de::Error::duplicate_field("stateTable"));
18394 }
18395 state_table__ = map_.next_value()?;
18396 }
18397 GeneratedField::TableDesc => {
18398 if table_desc__.is_some() {
18399 return Err(serde::de::Error::duplicate_field("tableDesc"));
18400 }
18401 table_desc__ = map_.next_value()?;
18402 }
18403 GeneratedField::RateLimit => {
18404 if rate_limit__.is_some() {
18405 return Err(serde::de::Error::duplicate_field("rateLimit"));
18406 }
18407 rate_limit__ =
18408 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18409 ;
18410 }
18411 GeneratedField::SnapshotReadBarrierInterval => {
18412 if snapshot_read_barrier_interval__.is_some() {
18413 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
18414 }
18415 snapshot_read_barrier_interval__ =
18416 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18417 ;
18418 }
18419 GeneratedField::ArrangementTable => {
18420 if arrangement_table__.is_some() {
18421 return Err(serde::de::Error::duplicate_field("arrangementTable"));
18422 }
18423 arrangement_table__ = map_.next_value()?;
18424 }
18425 GeneratedField::SnapshotBackfillEpoch => {
18426 if snapshot_backfill_epoch__.is_some() {
18427 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
18428 }
18429 snapshot_backfill_epoch__ =
18430 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18431 ;
18432 }
18433 GeneratedField::PkScanRange => {
18434 if pk_scan_range__.is_some() {
18435 return Err(serde::de::Error::duplicate_field("pkScanRange"));
18436 }
18437 pk_scan_range__ = map_.next_value()?;
18438 }
18439 }
18440 }
18441 Ok(StreamScanNode {
18442 table_id: table_id__.unwrap_or_default(),
18443 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
18444 output_indices: output_indices__.unwrap_or_default(),
18445 stream_scan_type: stream_scan_type__.unwrap_or_default(),
18446 state_table: state_table__,
18447 table_desc: table_desc__,
18448 rate_limit: rate_limit__,
18449 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
18450 arrangement_table: arrangement_table__,
18451 snapshot_backfill_epoch: snapshot_backfill_epoch__,
18452 pk_scan_range: pk_scan_range__,
18453 })
18454 }
18455 }
18456 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
18457 }
18458}
18459impl serde::Serialize for StreamScanType {
18460 #[allow(deprecated)]
18461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18462 where
18463 S: serde::Serializer,
18464 {
18465 let variant = match self {
18466 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
18467 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
18468 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
18469 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
18470 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
18471 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
18472 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
18473 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
18474 };
18475 serializer.serialize_str(variant)
18476 }
18477}
18478impl<'de> serde::Deserialize<'de> for StreamScanType {
18479 #[allow(deprecated)]
18480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18481 where
18482 D: serde::Deserializer<'de>,
18483 {
18484 const FIELDS: &[&str] = &[
18485 "STREAM_SCAN_TYPE_UNSPECIFIED",
18486 "STREAM_SCAN_TYPE_CHAIN",
18487 "STREAM_SCAN_TYPE_REARRANGE",
18488 "STREAM_SCAN_TYPE_BACKFILL",
18489 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
18490 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
18491 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
18492 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
18493 ];
18494
18495 struct GeneratedVisitor;
18496
18497 impl serde::de::Visitor<'_> for GeneratedVisitor {
18498 type Value = StreamScanType;
18499
18500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18501 write!(formatter, "expected one of: {:?}", &FIELDS)
18502 }
18503
18504 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18505 where
18506 E: serde::de::Error,
18507 {
18508 i32::try_from(v)
18509 .ok()
18510 .and_then(|x| x.try_into().ok())
18511 .ok_or_else(|| {
18512 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18513 })
18514 }
18515
18516 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18517 where
18518 E: serde::de::Error,
18519 {
18520 i32::try_from(v)
18521 .ok()
18522 .and_then(|x| x.try_into().ok())
18523 .ok_or_else(|| {
18524 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18525 })
18526 }
18527
18528 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18529 where
18530 E: serde::de::Error,
18531 {
18532 match value {
18533 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
18534 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
18535 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
18536 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
18537 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
18538 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
18539 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
18540 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
18541 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18542 }
18543 }
18544 }
18545 deserializer.deserialize_any(GeneratedVisitor)
18546 }
18547}
18548impl serde::Serialize for StreamSource {
18549 #[allow(deprecated)]
18550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18551 where
18552 S: serde::Serializer,
18553 {
18554 use serde::ser::SerializeStruct;
18555 let mut len = 0;
18556 if self.source_id != 0 {
18557 len += 1;
18558 }
18559 if self.state_table.is_some() {
18560 len += 1;
18561 }
18562 if self.row_id_index.is_some() {
18563 len += 1;
18564 }
18565 if !self.columns.is_empty() {
18566 len += 1;
18567 }
18568 if !self.with_properties.is_empty() {
18569 len += 1;
18570 }
18571 if self.info.is_some() {
18572 len += 1;
18573 }
18574 if !self.source_name.is_empty() {
18575 len += 1;
18576 }
18577 if self.rate_limit.is_some() {
18578 len += 1;
18579 }
18580 if !self.secret_refs.is_empty() {
18581 len += 1;
18582 }
18583 if self.downstream_columns.is_some() {
18584 len += 1;
18585 }
18586 if self.refresh_mode.is_some() {
18587 len += 1;
18588 }
18589 if self.associated_table_id.is_some() {
18590 len += 1;
18591 }
18592 if self.iceberg_fetch_state_table.is_some() {
18593 len += 1;
18594 }
18595 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
18596 if self.source_id != 0 {
18597 struct_ser.serialize_field("sourceId", &self.source_id)?;
18598 }
18599 if let Some(v) = self.state_table.as_ref() {
18600 struct_ser.serialize_field("stateTable", v)?;
18601 }
18602 if let Some(v) = self.row_id_index.as_ref() {
18603 struct_ser.serialize_field("rowIdIndex", v)?;
18604 }
18605 if !self.columns.is_empty() {
18606 struct_ser.serialize_field("columns", &self.columns)?;
18607 }
18608 if !self.with_properties.is_empty() {
18609 struct_ser.serialize_field("withProperties", &self.with_properties)?;
18610 }
18611 if let Some(v) = self.info.as_ref() {
18612 struct_ser.serialize_field("info", v)?;
18613 }
18614 if !self.source_name.is_empty() {
18615 struct_ser.serialize_field("sourceName", &self.source_name)?;
18616 }
18617 if let Some(v) = self.rate_limit.as_ref() {
18618 struct_ser.serialize_field("rateLimit", v)?;
18619 }
18620 if !self.secret_refs.is_empty() {
18621 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
18622 }
18623 if let Some(v) = self.downstream_columns.as_ref() {
18624 struct_ser.serialize_field("downstreamColumns", v)?;
18625 }
18626 if let Some(v) = self.refresh_mode.as_ref() {
18627 struct_ser.serialize_field("refreshMode", v)?;
18628 }
18629 if let Some(v) = self.associated_table_id.as_ref() {
18630 struct_ser.serialize_field("associatedTableId", v)?;
18631 }
18632 if let Some(v) = self.iceberg_fetch_state_table.as_ref() {
18633 struct_ser.serialize_field("icebergFetchStateTable", v)?;
18634 }
18635 struct_ser.end()
18636 }
18637}
18638impl<'de> serde::Deserialize<'de> for StreamSource {
18639 #[allow(deprecated)]
18640 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18641 where
18642 D: serde::Deserializer<'de>,
18643 {
18644 const FIELDS: &[&str] = &[
18645 "source_id",
18646 "sourceId",
18647 "state_table",
18648 "stateTable",
18649 "row_id_index",
18650 "rowIdIndex",
18651 "columns",
18652 "with_properties",
18653 "withProperties",
18654 "info",
18655 "source_name",
18656 "sourceName",
18657 "rate_limit",
18658 "rateLimit",
18659 "secret_refs",
18660 "secretRefs",
18661 "downstream_columns",
18662 "downstreamColumns",
18663 "refresh_mode",
18664 "refreshMode",
18665 "associated_table_id",
18666 "associatedTableId",
18667 "iceberg_fetch_state_table",
18668 "icebergFetchStateTable",
18669 ];
18670
18671 #[allow(clippy::enum_variant_names)]
18672 enum GeneratedField {
18673 SourceId,
18674 StateTable,
18675 RowIdIndex,
18676 Columns,
18677 WithProperties,
18678 Info,
18679 SourceName,
18680 RateLimit,
18681 SecretRefs,
18682 DownstreamColumns,
18683 RefreshMode,
18684 AssociatedTableId,
18685 IcebergFetchStateTable,
18686 }
18687 impl<'de> serde::Deserialize<'de> for GeneratedField {
18688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18689 where
18690 D: serde::Deserializer<'de>,
18691 {
18692 struct GeneratedVisitor;
18693
18694 impl serde::de::Visitor<'_> for GeneratedVisitor {
18695 type Value = GeneratedField;
18696
18697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18698 write!(formatter, "expected one of: {:?}", &FIELDS)
18699 }
18700
18701 #[allow(unused_variables)]
18702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18703 where
18704 E: serde::de::Error,
18705 {
18706 match value {
18707 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
18708 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
18709 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
18710 "columns" => Ok(GeneratedField::Columns),
18711 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
18712 "info" => Ok(GeneratedField::Info),
18713 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
18714 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
18715 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
18716 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
18717 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
18718 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
18719 "icebergFetchStateTable" | "iceberg_fetch_state_table" => Ok(GeneratedField::IcebergFetchStateTable),
18720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18721 }
18722 }
18723 }
18724 deserializer.deserialize_identifier(GeneratedVisitor)
18725 }
18726 }
18727 struct GeneratedVisitor;
18728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18729 type Value = StreamSource;
18730
18731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18732 formatter.write_str("struct stream_plan.StreamSource")
18733 }
18734
18735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
18736 where
18737 V: serde::de::MapAccess<'de>,
18738 {
18739 let mut source_id__ = None;
18740 let mut state_table__ = None;
18741 let mut row_id_index__ = None;
18742 let mut columns__ = None;
18743 let mut with_properties__ = None;
18744 let mut info__ = None;
18745 let mut source_name__ = None;
18746 let mut rate_limit__ = None;
18747 let mut secret_refs__ = None;
18748 let mut downstream_columns__ = None;
18749 let mut refresh_mode__ = None;
18750 let mut associated_table_id__ = None;
18751 let mut iceberg_fetch_state_table__ = None;
18752 while let Some(k) = map_.next_key()? {
18753 match k {
18754 GeneratedField::SourceId => {
18755 if source_id__.is_some() {
18756 return Err(serde::de::Error::duplicate_field("sourceId"));
18757 }
18758 source_id__ =
18759 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18760 ;
18761 }
18762 GeneratedField::StateTable => {
18763 if state_table__.is_some() {
18764 return Err(serde::de::Error::duplicate_field("stateTable"));
18765 }
18766 state_table__ = map_.next_value()?;
18767 }
18768 GeneratedField::RowIdIndex => {
18769 if row_id_index__.is_some() {
18770 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
18771 }
18772 row_id_index__ =
18773 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18774 ;
18775 }
18776 GeneratedField::Columns => {
18777 if columns__.is_some() {
18778 return Err(serde::de::Error::duplicate_field("columns"));
18779 }
18780 columns__ = Some(map_.next_value()?);
18781 }
18782 GeneratedField::WithProperties => {
18783 if with_properties__.is_some() {
18784 return Err(serde::de::Error::duplicate_field("withProperties"));
18785 }
18786 with_properties__ = Some(
18787 map_.next_value::<std::collections::BTreeMap<_, _>>()?
18788 );
18789 }
18790 GeneratedField::Info => {
18791 if info__.is_some() {
18792 return Err(serde::de::Error::duplicate_field("info"));
18793 }
18794 info__ = map_.next_value()?;
18795 }
18796 GeneratedField::SourceName => {
18797 if source_name__.is_some() {
18798 return Err(serde::de::Error::duplicate_field("sourceName"));
18799 }
18800 source_name__ = Some(map_.next_value()?);
18801 }
18802 GeneratedField::RateLimit => {
18803 if rate_limit__.is_some() {
18804 return Err(serde::de::Error::duplicate_field("rateLimit"));
18805 }
18806 rate_limit__ =
18807 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18808 ;
18809 }
18810 GeneratedField::SecretRefs => {
18811 if secret_refs__.is_some() {
18812 return Err(serde::de::Error::duplicate_field("secretRefs"));
18813 }
18814 secret_refs__ = Some(
18815 map_.next_value::<std::collections::BTreeMap<_, _>>()?
18816 );
18817 }
18818 GeneratedField::DownstreamColumns => {
18819 if downstream_columns__.is_some() {
18820 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
18821 }
18822 downstream_columns__ = map_.next_value()?;
18823 }
18824 GeneratedField::RefreshMode => {
18825 if refresh_mode__.is_some() {
18826 return Err(serde::de::Error::duplicate_field("refreshMode"));
18827 }
18828 refresh_mode__ = map_.next_value()?;
18829 }
18830 GeneratedField::AssociatedTableId => {
18831 if associated_table_id__.is_some() {
18832 return Err(serde::de::Error::duplicate_field("associatedTableId"));
18833 }
18834 associated_table_id__ =
18835 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18836 ;
18837 }
18838 GeneratedField::IcebergFetchStateTable => {
18839 if iceberg_fetch_state_table__.is_some() {
18840 return Err(serde::de::Error::duplicate_field("icebergFetchStateTable"));
18841 }
18842 iceberg_fetch_state_table__ = map_.next_value()?;
18843 }
18844 }
18845 }
18846 Ok(StreamSource {
18847 source_id: source_id__.unwrap_or_default(),
18848 state_table: state_table__,
18849 row_id_index: row_id_index__,
18850 columns: columns__.unwrap_or_default(),
18851 with_properties: with_properties__.unwrap_or_default(),
18852 info: info__,
18853 source_name: source_name__.unwrap_or_default(),
18854 rate_limit: rate_limit__,
18855 secret_refs: secret_refs__.unwrap_or_default(),
18856 downstream_columns: downstream_columns__,
18857 refresh_mode: refresh_mode__,
18858 associated_table_id: associated_table_id__,
18859 iceberg_fetch_state_table: iceberg_fetch_state_table__,
18860 })
18861 }
18862 }
18863 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
18864 }
18865}
18866impl serde::Serialize for SubscriptionUpstreamInfo {
18867 #[allow(deprecated)]
18868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18869 where
18870 S: serde::Serializer,
18871 {
18872 use serde::ser::SerializeStruct;
18873 let mut len = 0;
18874 if self.subscriber_id != 0 {
18875 len += 1;
18876 }
18877 if self.upstream_mv_table_id != 0 {
18878 len += 1;
18879 }
18880 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
18881 if self.subscriber_id != 0 {
18882 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
18883 }
18884 if self.upstream_mv_table_id != 0 {
18885 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
18886 }
18887 struct_ser.end()
18888 }
18889}
18890impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
18891 #[allow(deprecated)]
18892 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18893 where
18894 D: serde::Deserializer<'de>,
18895 {
18896 const FIELDS: &[&str] = &[
18897 "subscriber_id",
18898 "subscriberId",
18899 "upstream_mv_table_id",
18900 "upstreamMvTableId",
18901 ];
18902
18903 #[allow(clippy::enum_variant_names)]
18904 enum GeneratedField {
18905 SubscriberId,
18906 UpstreamMvTableId,
18907 }
18908 impl<'de> serde::Deserialize<'de> for GeneratedField {
18909 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18910 where
18911 D: serde::Deserializer<'de>,
18912 {
18913 struct GeneratedVisitor;
18914
18915 impl serde::de::Visitor<'_> for GeneratedVisitor {
18916 type Value = GeneratedField;
18917
18918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18919 write!(formatter, "expected one of: {:?}", &FIELDS)
18920 }
18921
18922 #[allow(unused_variables)]
18923 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18924 where
18925 E: serde::de::Error,
18926 {
18927 match value {
18928 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
18929 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
18930 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18931 }
18932 }
18933 }
18934 deserializer.deserialize_identifier(GeneratedVisitor)
18935 }
18936 }
18937 struct GeneratedVisitor;
18938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18939 type Value = SubscriptionUpstreamInfo;
18940
18941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18942 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
18943 }
18944
18945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
18946 where
18947 V: serde::de::MapAccess<'de>,
18948 {
18949 let mut subscriber_id__ = None;
18950 let mut upstream_mv_table_id__ = None;
18951 while let Some(k) = map_.next_key()? {
18952 match k {
18953 GeneratedField::SubscriberId => {
18954 if subscriber_id__.is_some() {
18955 return Err(serde::de::Error::duplicate_field("subscriberId"));
18956 }
18957 subscriber_id__ =
18958 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18959 ;
18960 }
18961 GeneratedField::UpstreamMvTableId => {
18962 if upstream_mv_table_id__.is_some() {
18963 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
18964 }
18965 upstream_mv_table_id__ =
18966 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18967 ;
18968 }
18969 }
18970 }
18971 Ok(SubscriptionUpstreamInfo {
18972 subscriber_id: subscriber_id__.unwrap_or_default(),
18973 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
18974 })
18975 }
18976 }
18977 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
18978 }
18979}
18980impl serde::Serialize for SyncLogStoreNode {
18981 #[allow(deprecated)]
18982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18983 where
18984 S: serde::Serializer,
18985 {
18986 use serde::ser::SerializeStruct;
18987 let mut len = 0;
18988 if self.log_store_table.is_some() {
18989 len += 1;
18990 }
18991 if self.pause_duration_ms.is_some() {
18992 len += 1;
18993 }
18994 if self.buffer_size.is_some() {
18995 len += 1;
18996 }
18997 if self.aligned {
18998 len += 1;
18999 }
19000 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
19001 if let Some(v) = self.log_store_table.as_ref() {
19002 struct_ser.serialize_field("logStoreTable", v)?;
19003 }
19004 if let Some(v) = self.pause_duration_ms.as_ref() {
19005 struct_ser.serialize_field("pauseDurationMs", v)?;
19006 }
19007 if let Some(v) = self.buffer_size.as_ref() {
19008 struct_ser.serialize_field("bufferSize", v)?;
19009 }
19010 if self.aligned {
19011 struct_ser.serialize_field("aligned", &self.aligned)?;
19012 }
19013 struct_ser.end()
19014 }
19015}
19016impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
19017 #[allow(deprecated)]
19018 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19019 where
19020 D: serde::Deserializer<'de>,
19021 {
19022 const FIELDS: &[&str] = &[
19023 "log_store_table",
19024 "logStoreTable",
19025 "pause_duration_ms",
19026 "pauseDurationMs",
19027 "buffer_size",
19028 "bufferSize",
19029 "aligned",
19030 ];
19031
19032 #[allow(clippy::enum_variant_names)]
19033 enum GeneratedField {
19034 LogStoreTable,
19035 PauseDurationMs,
19036 BufferSize,
19037 Aligned,
19038 }
19039 impl<'de> serde::Deserialize<'de> for GeneratedField {
19040 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19041 where
19042 D: serde::Deserializer<'de>,
19043 {
19044 struct GeneratedVisitor;
19045
19046 impl serde::de::Visitor<'_> for GeneratedVisitor {
19047 type Value = GeneratedField;
19048
19049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19050 write!(formatter, "expected one of: {:?}", &FIELDS)
19051 }
19052
19053 #[allow(unused_variables)]
19054 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19055 where
19056 E: serde::de::Error,
19057 {
19058 match value {
19059 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
19060 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
19061 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
19062 "aligned" => Ok(GeneratedField::Aligned),
19063 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19064 }
19065 }
19066 }
19067 deserializer.deserialize_identifier(GeneratedVisitor)
19068 }
19069 }
19070 struct GeneratedVisitor;
19071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19072 type Value = SyncLogStoreNode;
19073
19074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19075 formatter.write_str("struct stream_plan.SyncLogStoreNode")
19076 }
19077
19078 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
19079 where
19080 V: serde::de::MapAccess<'de>,
19081 {
19082 let mut log_store_table__ = None;
19083 let mut pause_duration_ms__ = None;
19084 let mut buffer_size__ = None;
19085 let mut aligned__ = None;
19086 while let Some(k) = map_.next_key()? {
19087 match k {
19088 GeneratedField::LogStoreTable => {
19089 if log_store_table__.is_some() {
19090 return Err(serde::de::Error::duplicate_field("logStoreTable"));
19091 }
19092 log_store_table__ = map_.next_value()?;
19093 }
19094 GeneratedField::PauseDurationMs => {
19095 if pause_duration_ms__.is_some() {
19096 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
19097 }
19098 pause_duration_ms__ =
19099 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
19100 ;
19101 }
19102 GeneratedField::BufferSize => {
19103 if buffer_size__.is_some() {
19104 return Err(serde::de::Error::duplicate_field("bufferSize"));
19105 }
19106 buffer_size__ =
19107 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
19108 ;
19109 }
19110 GeneratedField::Aligned => {
19111 if aligned__.is_some() {
19112 return Err(serde::de::Error::duplicate_field("aligned"));
19113 }
19114 aligned__ = Some(map_.next_value()?);
19115 }
19116 }
19117 }
19118 Ok(SyncLogStoreNode {
19119 log_store_table: log_store_table__,
19120 pause_duration_ms: pause_duration_ms__,
19121 buffer_size: buffer_size__,
19122 aligned: aligned__.unwrap_or_default(),
19123 })
19124 }
19125 }
19126 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
19127 }
19128}
19129impl serde::Serialize for TemporalJoinNode {
19130 #[allow(deprecated)]
19131 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19132 where
19133 S: serde::Serializer,
19134 {
19135 use serde::ser::SerializeStruct;
19136 let mut len = 0;
19137 if self.join_type != 0 {
19138 len += 1;
19139 }
19140 if !self.left_key.is_empty() {
19141 len += 1;
19142 }
19143 if !self.right_key.is_empty() {
19144 len += 1;
19145 }
19146 if !self.null_safe.is_empty() {
19147 len += 1;
19148 }
19149 if self.condition.is_some() {
19150 len += 1;
19151 }
19152 if !self.output_indices.is_empty() {
19153 len += 1;
19154 }
19155 if self.table_desc.is_some() {
19156 len += 1;
19157 }
19158 if !self.table_output_indices.is_empty() {
19159 len += 1;
19160 }
19161 if self.memo_table.is_some() {
19162 len += 1;
19163 }
19164 if self.is_nested_loop {
19165 len += 1;
19166 }
19167 if self.is_broadcast {
19168 len += 1;
19169 }
19170 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
19171 if self.join_type != 0 {
19172 let v = super::plan_common::JoinType::try_from(self.join_type)
19173 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
19174 struct_ser.serialize_field("joinType", &v)?;
19175 }
19176 if !self.left_key.is_empty() {
19177 struct_ser.serialize_field("leftKey", &self.left_key)?;
19178 }
19179 if !self.right_key.is_empty() {
19180 struct_ser.serialize_field("rightKey", &self.right_key)?;
19181 }
19182 if !self.null_safe.is_empty() {
19183 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
19184 }
19185 if let Some(v) = self.condition.as_ref() {
19186 struct_ser.serialize_field("condition", v)?;
19187 }
19188 if !self.output_indices.is_empty() {
19189 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
19190 }
19191 if let Some(v) = self.table_desc.as_ref() {
19192 struct_ser.serialize_field("tableDesc", v)?;
19193 }
19194 if !self.table_output_indices.is_empty() {
19195 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
19196 }
19197 if let Some(v) = self.memo_table.as_ref() {
19198 struct_ser.serialize_field("memoTable", v)?;
19199 }
19200 if self.is_nested_loop {
19201 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
19202 }
19203 if self.is_broadcast {
19204 struct_ser.serialize_field("isBroadcast", &self.is_broadcast)?;
19205 }
19206 struct_ser.end()
19207 }
19208}
19209impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
19210 #[allow(deprecated)]
19211 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19212 where
19213 D: serde::Deserializer<'de>,
19214 {
19215 const FIELDS: &[&str] = &[
19216 "join_type",
19217 "joinType",
19218 "left_key",
19219 "leftKey",
19220 "right_key",
19221 "rightKey",
19222 "null_safe",
19223 "nullSafe",
19224 "condition",
19225 "output_indices",
19226 "outputIndices",
19227 "table_desc",
19228 "tableDesc",
19229 "table_output_indices",
19230 "tableOutputIndices",
19231 "memo_table",
19232 "memoTable",
19233 "is_nested_loop",
19234 "isNestedLoop",
19235 "is_broadcast",
19236 "isBroadcast",
19237 ];
19238
19239 #[allow(clippy::enum_variant_names)]
19240 enum GeneratedField {
19241 JoinType,
19242 LeftKey,
19243 RightKey,
19244 NullSafe,
19245 Condition,
19246 OutputIndices,
19247 TableDesc,
19248 TableOutputIndices,
19249 MemoTable,
19250 IsNestedLoop,
19251 IsBroadcast,
19252 }
19253 impl<'de> serde::Deserialize<'de> for GeneratedField {
19254 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19255 where
19256 D: serde::Deserializer<'de>,
19257 {
19258 struct GeneratedVisitor;
19259
19260 impl serde::de::Visitor<'_> for GeneratedVisitor {
19261 type Value = GeneratedField;
19262
19263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19264 write!(formatter, "expected one of: {:?}", &FIELDS)
19265 }
19266
19267 #[allow(unused_variables)]
19268 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19269 where
19270 E: serde::de::Error,
19271 {
19272 match value {
19273 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
19274 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
19275 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
19276 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
19277 "condition" => Ok(GeneratedField::Condition),
19278 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
19279 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
19280 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
19281 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
19282 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
19283 "isBroadcast" | "is_broadcast" => Ok(GeneratedField::IsBroadcast),
19284 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19285 }
19286 }
19287 }
19288 deserializer.deserialize_identifier(GeneratedVisitor)
19289 }
19290 }
19291 struct GeneratedVisitor;
19292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19293 type Value = TemporalJoinNode;
19294
19295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19296 formatter.write_str("struct stream_plan.TemporalJoinNode")
19297 }
19298
19299 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
19300 where
19301 V: serde::de::MapAccess<'de>,
19302 {
19303 let mut join_type__ = None;
19304 let mut left_key__ = None;
19305 let mut right_key__ = None;
19306 let mut null_safe__ = None;
19307 let mut condition__ = None;
19308 let mut output_indices__ = None;
19309 let mut table_desc__ = None;
19310 let mut table_output_indices__ = None;
19311 let mut memo_table__ = None;
19312 let mut is_nested_loop__ = None;
19313 let mut is_broadcast__ = None;
19314 while let Some(k) = map_.next_key()? {
19315 match k {
19316 GeneratedField::JoinType => {
19317 if join_type__.is_some() {
19318 return Err(serde::de::Error::duplicate_field("joinType"));
19319 }
19320 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
19321 }
19322 GeneratedField::LeftKey => {
19323 if left_key__.is_some() {
19324 return Err(serde::de::Error::duplicate_field("leftKey"));
19325 }
19326 left_key__ =
19327 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19328 .into_iter().map(|x| x.0).collect())
19329 ;
19330 }
19331 GeneratedField::RightKey => {
19332 if right_key__.is_some() {
19333 return Err(serde::de::Error::duplicate_field("rightKey"));
19334 }
19335 right_key__ =
19336 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19337 .into_iter().map(|x| x.0).collect())
19338 ;
19339 }
19340 GeneratedField::NullSafe => {
19341 if null_safe__.is_some() {
19342 return Err(serde::de::Error::duplicate_field("nullSafe"));
19343 }
19344 null_safe__ = Some(map_.next_value()?);
19345 }
19346 GeneratedField::Condition => {
19347 if condition__.is_some() {
19348 return Err(serde::de::Error::duplicate_field("condition"));
19349 }
19350 condition__ = map_.next_value()?;
19351 }
19352 GeneratedField::OutputIndices => {
19353 if output_indices__.is_some() {
19354 return Err(serde::de::Error::duplicate_field("outputIndices"));
19355 }
19356 output_indices__ =
19357 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19358 .into_iter().map(|x| x.0).collect())
19359 ;
19360 }
19361 GeneratedField::TableDesc => {
19362 if table_desc__.is_some() {
19363 return Err(serde::de::Error::duplicate_field("tableDesc"));
19364 }
19365 table_desc__ = map_.next_value()?;
19366 }
19367 GeneratedField::TableOutputIndices => {
19368 if table_output_indices__.is_some() {
19369 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
19370 }
19371 table_output_indices__ =
19372 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19373 .into_iter().map(|x| x.0).collect())
19374 ;
19375 }
19376 GeneratedField::MemoTable => {
19377 if memo_table__.is_some() {
19378 return Err(serde::de::Error::duplicate_field("memoTable"));
19379 }
19380 memo_table__ = map_.next_value()?;
19381 }
19382 GeneratedField::IsNestedLoop => {
19383 if is_nested_loop__.is_some() {
19384 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
19385 }
19386 is_nested_loop__ = Some(map_.next_value()?);
19387 }
19388 GeneratedField::IsBroadcast => {
19389 if is_broadcast__.is_some() {
19390 return Err(serde::de::Error::duplicate_field("isBroadcast"));
19391 }
19392 is_broadcast__ = Some(map_.next_value()?);
19393 }
19394 }
19395 }
19396 Ok(TemporalJoinNode {
19397 join_type: join_type__.unwrap_or_default(),
19398 left_key: left_key__.unwrap_or_default(),
19399 right_key: right_key__.unwrap_or_default(),
19400 null_safe: null_safe__.unwrap_or_default(),
19401 condition: condition__,
19402 output_indices: output_indices__.unwrap_or_default(),
19403 table_desc: table_desc__,
19404 table_output_indices: table_output_indices__.unwrap_or_default(),
19405 memo_table: memo_table__,
19406 is_nested_loop: is_nested_loop__.unwrap_or_default(),
19407 is_broadcast: is_broadcast__.unwrap_or_default(),
19408 })
19409 }
19410 }
19411 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
19412 }
19413}
19414impl serde::Serialize for ThrottleMutation {
19415 #[allow(deprecated)]
19416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19417 where
19418 S: serde::Serializer,
19419 {
19420 use serde::ser::SerializeStruct;
19421 let mut len = 0;
19422 if !self.fragment_throttle.is_empty() {
19423 len += 1;
19424 }
19425 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
19426 if !self.fragment_throttle.is_empty() {
19427 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
19428 }
19429 struct_ser.end()
19430 }
19431}
19432impl<'de> serde::Deserialize<'de> for ThrottleMutation {
19433 #[allow(deprecated)]
19434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19435 where
19436 D: serde::Deserializer<'de>,
19437 {
19438 const FIELDS: &[&str] = &[
19439 "fragment_throttle",
19440 "fragmentThrottle",
19441 ];
19442
19443 #[allow(clippy::enum_variant_names)]
19444 enum GeneratedField {
19445 FragmentThrottle,
19446 }
19447 impl<'de> serde::Deserialize<'de> for GeneratedField {
19448 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19449 where
19450 D: serde::Deserializer<'de>,
19451 {
19452 struct GeneratedVisitor;
19453
19454 impl serde::de::Visitor<'_> for GeneratedVisitor {
19455 type Value = GeneratedField;
19456
19457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19458 write!(formatter, "expected one of: {:?}", &FIELDS)
19459 }
19460
19461 #[allow(unused_variables)]
19462 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19463 where
19464 E: serde::de::Error,
19465 {
19466 match value {
19467 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
19468 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19469 }
19470 }
19471 }
19472 deserializer.deserialize_identifier(GeneratedVisitor)
19473 }
19474 }
19475 struct GeneratedVisitor;
19476 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19477 type Value = ThrottleMutation;
19478
19479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19480 formatter.write_str("struct stream_plan.ThrottleMutation")
19481 }
19482
19483 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
19484 where
19485 V: serde::de::MapAccess<'de>,
19486 {
19487 let mut fragment_throttle__ = None;
19488 while let Some(k) = map_.next_key()? {
19489 match k {
19490 GeneratedField::FragmentThrottle => {
19491 if fragment_throttle__.is_some() {
19492 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
19493 }
19494 fragment_throttle__ = Some(
19495 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19496 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19497 );
19498 }
19499 }
19500 }
19501 Ok(ThrottleMutation {
19502 fragment_throttle: fragment_throttle__.unwrap_or_default(),
19503 })
19504 }
19505 }
19506 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
19507 }
19508}
19509impl serde::Serialize for throttle_mutation::ThrottleConfig {
19510 #[allow(deprecated)]
19511 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19512 where
19513 S: serde::Serializer,
19514 {
19515 use serde::ser::SerializeStruct;
19516 let mut len = 0;
19517 if self.rate_limit.is_some() {
19518 len += 1;
19519 }
19520 if self.throttle_type != 0 {
19521 len += 1;
19522 }
19523 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
19524 if let Some(v) = self.rate_limit.as_ref() {
19525 struct_ser.serialize_field("rateLimit", v)?;
19526 }
19527 if self.throttle_type != 0 {
19528 let v = super::common::ThrottleType::try_from(self.throttle_type)
19529 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
19530 struct_ser.serialize_field("throttleType", &v)?;
19531 }
19532 struct_ser.end()
19533 }
19534}
19535impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
19536 #[allow(deprecated)]
19537 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19538 where
19539 D: serde::Deserializer<'de>,
19540 {
19541 const FIELDS: &[&str] = &[
19542 "rate_limit",
19543 "rateLimit",
19544 "throttle_type",
19545 "throttleType",
19546 ];
19547
19548 #[allow(clippy::enum_variant_names)]
19549 enum GeneratedField {
19550 RateLimit,
19551 ThrottleType,
19552 }
19553 impl<'de> serde::Deserialize<'de> for GeneratedField {
19554 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19555 where
19556 D: serde::Deserializer<'de>,
19557 {
19558 struct GeneratedVisitor;
19559
19560 impl serde::de::Visitor<'_> for GeneratedVisitor {
19561 type Value = GeneratedField;
19562
19563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19564 write!(formatter, "expected one of: {:?}", &FIELDS)
19565 }
19566
19567 #[allow(unused_variables)]
19568 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19569 where
19570 E: serde::de::Error,
19571 {
19572 match value {
19573 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
19574 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
19575 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19576 }
19577 }
19578 }
19579 deserializer.deserialize_identifier(GeneratedVisitor)
19580 }
19581 }
19582 struct GeneratedVisitor;
19583 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19584 type Value = throttle_mutation::ThrottleConfig;
19585
19586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19587 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
19588 }
19589
19590 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
19591 where
19592 V: serde::de::MapAccess<'de>,
19593 {
19594 let mut rate_limit__ = None;
19595 let mut throttle_type__ = None;
19596 while let Some(k) = map_.next_key()? {
19597 match k {
19598 GeneratedField::RateLimit => {
19599 if rate_limit__.is_some() {
19600 return Err(serde::de::Error::duplicate_field("rateLimit"));
19601 }
19602 rate_limit__ =
19603 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
19604 ;
19605 }
19606 GeneratedField::ThrottleType => {
19607 if throttle_type__.is_some() {
19608 return Err(serde::de::Error::duplicate_field("throttleType"));
19609 }
19610 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
19611 }
19612 }
19613 }
19614 Ok(throttle_mutation::ThrottleConfig {
19615 rate_limit: rate_limit__,
19616 throttle_type: throttle_type__.unwrap_or_default(),
19617 })
19618 }
19619 }
19620 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
19621 }
19622}
19623impl serde::Serialize for TopNNode {
19624 #[allow(deprecated)]
19625 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19626 where
19627 S: serde::Serializer,
19628 {
19629 use serde::ser::SerializeStruct;
19630 let mut len = 0;
19631 if self.limit != 0 {
19632 len += 1;
19633 }
19634 if self.offset != 0 {
19635 len += 1;
19636 }
19637 if self.table.is_some() {
19638 len += 1;
19639 }
19640 if !self.order_by.is_empty() {
19641 len += 1;
19642 }
19643 if self.with_ties {
19644 len += 1;
19645 }
19646 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
19647 if self.limit != 0 {
19648 #[allow(clippy::needless_borrow)]
19649 #[allow(clippy::needless_borrows_for_generic_args)]
19650 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
19651 }
19652 if self.offset != 0 {
19653 #[allow(clippy::needless_borrow)]
19654 #[allow(clippy::needless_borrows_for_generic_args)]
19655 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
19656 }
19657 if let Some(v) = self.table.as_ref() {
19658 struct_ser.serialize_field("table", v)?;
19659 }
19660 if !self.order_by.is_empty() {
19661 struct_ser.serialize_field("orderBy", &self.order_by)?;
19662 }
19663 if self.with_ties {
19664 struct_ser.serialize_field("withTies", &self.with_ties)?;
19665 }
19666 struct_ser.end()
19667 }
19668}
19669impl<'de> serde::Deserialize<'de> for TopNNode {
19670 #[allow(deprecated)]
19671 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19672 where
19673 D: serde::Deserializer<'de>,
19674 {
19675 const FIELDS: &[&str] = &[
19676 "limit",
19677 "offset",
19678 "table",
19679 "order_by",
19680 "orderBy",
19681 "with_ties",
19682 "withTies",
19683 ];
19684
19685 #[allow(clippy::enum_variant_names)]
19686 enum GeneratedField {
19687 Limit,
19688 Offset,
19689 Table,
19690 OrderBy,
19691 WithTies,
19692 }
19693 impl<'de> serde::Deserialize<'de> for GeneratedField {
19694 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19695 where
19696 D: serde::Deserializer<'de>,
19697 {
19698 struct GeneratedVisitor;
19699
19700 impl serde::de::Visitor<'_> for GeneratedVisitor {
19701 type Value = GeneratedField;
19702
19703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19704 write!(formatter, "expected one of: {:?}", &FIELDS)
19705 }
19706
19707 #[allow(unused_variables)]
19708 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19709 where
19710 E: serde::de::Error,
19711 {
19712 match value {
19713 "limit" => Ok(GeneratedField::Limit),
19714 "offset" => Ok(GeneratedField::Offset),
19715 "table" => Ok(GeneratedField::Table),
19716 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
19717 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
19718 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19719 }
19720 }
19721 }
19722 deserializer.deserialize_identifier(GeneratedVisitor)
19723 }
19724 }
19725 struct GeneratedVisitor;
19726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19727 type Value = TopNNode;
19728
19729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19730 formatter.write_str("struct stream_plan.TopNNode")
19731 }
19732
19733 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
19734 where
19735 V: serde::de::MapAccess<'de>,
19736 {
19737 let mut limit__ = None;
19738 let mut offset__ = None;
19739 let mut table__ = None;
19740 let mut order_by__ = None;
19741 let mut with_ties__ = None;
19742 while let Some(k) = map_.next_key()? {
19743 match k {
19744 GeneratedField::Limit => {
19745 if limit__.is_some() {
19746 return Err(serde::de::Error::duplicate_field("limit"));
19747 }
19748 limit__ =
19749 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19750 ;
19751 }
19752 GeneratedField::Offset => {
19753 if offset__.is_some() {
19754 return Err(serde::de::Error::duplicate_field("offset"));
19755 }
19756 offset__ =
19757 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19758 ;
19759 }
19760 GeneratedField::Table => {
19761 if table__.is_some() {
19762 return Err(serde::de::Error::duplicate_field("table"));
19763 }
19764 table__ = map_.next_value()?;
19765 }
19766 GeneratedField::OrderBy => {
19767 if order_by__.is_some() {
19768 return Err(serde::de::Error::duplicate_field("orderBy"));
19769 }
19770 order_by__ = Some(map_.next_value()?);
19771 }
19772 GeneratedField::WithTies => {
19773 if with_ties__.is_some() {
19774 return Err(serde::de::Error::duplicate_field("withTies"));
19775 }
19776 with_ties__ = Some(map_.next_value()?);
19777 }
19778 }
19779 }
19780 Ok(TopNNode {
19781 limit: limit__.unwrap_or_default(),
19782 offset: offset__.unwrap_or_default(),
19783 table: table__,
19784 order_by: order_by__.unwrap_or_default(),
19785 with_ties: with_ties__.unwrap_or_default(),
19786 })
19787 }
19788 }
19789 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
19790 }
19791}
19792impl serde::Serialize for UnionNode {
19793 #[allow(deprecated)]
19794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19795 where
19796 S: serde::Serializer,
19797 {
19798 use serde::ser::SerializeStruct;
19799 let len = 0;
19800 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
19801 struct_ser.end()
19802 }
19803}
19804impl<'de> serde::Deserialize<'de> for UnionNode {
19805 #[allow(deprecated)]
19806 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19807 where
19808 D: serde::Deserializer<'de>,
19809 {
19810 const FIELDS: &[&str] = &[
19811 ];
19812
19813 #[allow(clippy::enum_variant_names)]
19814 enum GeneratedField {
19815 }
19816 impl<'de> serde::Deserialize<'de> for GeneratedField {
19817 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19818 where
19819 D: serde::Deserializer<'de>,
19820 {
19821 struct GeneratedVisitor;
19822
19823 impl serde::de::Visitor<'_> for GeneratedVisitor {
19824 type Value = GeneratedField;
19825
19826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19827 write!(formatter, "expected one of: {:?}", &FIELDS)
19828 }
19829
19830 #[allow(unused_variables)]
19831 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19832 where
19833 E: serde::de::Error,
19834 {
19835 Err(serde::de::Error::unknown_field(value, FIELDS))
19836 }
19837 }
19838 deserializer.deserialize_identifier(GeneratedVisitor)
19839 }
19840 }
19841 struct GeneratedVisitor;
19842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19843 type Value = UnionNode;
19844
19845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19846 formatter.write_str("struct stream_plan.UnionNode")
19847 }
19848
19849 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
19850 where
19851 V: serde::de::MapAccess<'de>,
19852 {
19853 while map_.next_key::<GeneratedField>()?.is_some() {
19854 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19855 }
19856 Ok(UnionNode {
19857 })
19858 }
19859 }
19860 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
19861 }
19862}
19863impl serde::Serialize for UpdateMutation {
19864 #[allow(deprecated)]
19865 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19866 where
19867 S: serde::Serializer,
19868 {
19869 use serde::ser::SerializeStruct;
19870 let mut len = 0;
19871 if !self.dispatcher_update.is_empty() {
19872 len += 1;
19873 }
19874 if !self.merge_update.is_empty() {
19875 len += 1;
19876 }
19877 if !self.actor_vnode_bitmap_update.is_empty() {
19878 len += 1;
19879 }
19880 if !self.dropped_actors.is_empty() {
19881 len += 1;
19882 }
19883 if !self.actor_splits.is_empty() {
19884 len += 1;
19885 }
19886 if !self.actor_new_dispatchers.is_empty() {
19887 len += 1;
19888 }
19889 if self.actor_cdc_table_snapshot_splits.is_some() {
19890 len += 1;
19891 }
19892 if !self.sink_schema_change.is_empty() {
19893 len += 1;
19894 }
19895 if !self.subscriptions_to_drop.is_empty() {
19896 len += 1;
19897 }
19898 if self.iceberg_pk_index_compaction.is_some() {
19899 len += 1;
19900 }
19901 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
19902 if !self.dispatcher_update.is_empty() {
19903 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
19904 }
19905 if !self.merge_update.is_empty() {
19906 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
19907 }
19908 if !self.actor_vnode_bitmap_update.is_empty() {
19909 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
19910 }
19911 if !self.dropped_actors.is_empty() {
19912 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
19913 }
19914 if !self.actor_splits.is_empty() {
19915 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
19916 }
19917 if !self.actor_new_dispatchers.is_empty() {
19918 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
19919 }
19920 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
19921 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
19922 }
19923 if !self.sink_schema_change.is_empty() {
19924 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
19925 }
19926 if !self.subscriptions_to_drop.is_empty() {
19927 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
19928 }
19929 if let Some(v) = self.iceberg_pk_index_compaction.as_ref() {
19930 struct_ser.serialize_field("icebergPkIndexCompaction", v)?;
19931 }
19932 struct_ser.end()
19933 }
19934}
19935impl<'de> serde::Deserialize<'de> for UpdateMutation {
19936 #[allow(deprecated)]
19937 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19938 where
19939 D: serde::Deserializer<'de>,
19940 {
19941 const FIELDS: &[&str] = &[
19942 "dispatcher_update",
19943 "dispatcherUpdate",
19944 "merge_update",
19945 "mergeUpdate",
19946 "actor_vnode_bitmap_update",
19947 "actorVnodeBitmapUpdate",
19948 "dropped_actors",
19949 "droppedActors",
19950 "actor_splits",
19951 "actorSplits",
19952 "actor_new_dispatchers",
19953 "actorNewDispatchers",
19954 "actor_cdc_table_snapshot_splits",
19955 "actorCdcTableSnapshotSplits",
19956 "sink_schema_change",
19957 "sinkSchemaChange",
19958 "subscriptions_to_drop",
19959 "subscriptionsToDrop",
19960 "iceberg_pk_index_compaction",
19961 "icebergPkIndexCompaction",
19962 ];
19963
19964 #[allow(clippy::enum_variant_names)]
19965 enum GeneratedField {
19966 DispatcherUpdate,
19967 MergeUpdate,
19968 ActorVnodeBitmapUpdate,
19969 DroppedActors,
19970 ActorSplits,
19971 ActorNewDispatchers,
19972 ActorCdcTableSnapshotSplits,
19973 SinkSchemaChange,
19974 SubscriptionsToDrop,
19975 IcebergPkIndexCompaction,
19976 }
19977 impl<'de> serde::Deserialize<'de> for GeneratedField {
19978 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19979 where
19980 D: serde::Deserializer<'de>,
19981 {
19982 struct GeneratedVisitor;
19983
19984 impl serde::de::Visitor<'_> for GeneratedVisitor {
19985 type Value = GeneratedField;
19986
19987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19988 write!(formatter, "expected one of: {:?}", &FIELDS)
19989 }
19990
19991 #[allow(unused_variables)]
19992 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19993 where
19994 E: serde::de::Error,
19995 {
19996 match value {
19997 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
19998 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
19999 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
20000 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
20001 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
20002 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
20003 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
20004 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
20005 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
20006 "icebergPkIndexCompaction" | "iceberg_pk_index_compaction" => Ok(GeneratedField::IcebergPkIndexCompaction),
20007 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20008 }
20009 }
20010 }
20011 deserializer.deserialize_identifier(GeneratedVisitor)
20012 }
20013 }
20014 struct GeneratedVisitor;
20015 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20016 type Value = UpdateMutation;
20017
20018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20019 formatter.write_str("struct stream_plan.UpdateMutation")
20020 }
20021
20022 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
20023 where
20024 V: serde::de::MapAccess<'de>,
20025 {
20026 let mut dispatcher_update__ = None;
20027 let mut merge_update__ = None;
20028 let mut actor_vnode_bitmap_update__ = None;
20029 let mut dropped_actors__ = None;
20030 let mut actor_splits__ = None;
20031 let mut actor_new_dispatchers__ = None;
20032 let mut actor_cdc_table_snapshot_splits__ = None;
20033 let mut sink_schema_change__ = None;
20034 let mut subscriptions_to_drop__ = None;
20035 let mut iceberg_pk_index_compaction__ = None;
20036 while let Some(k) = map_.next_key()? {
20037 match k {
20038 GeneratedField::DispatcherUpdate => {
20039 if dispatcher_update__.is_some() {
20040 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
20041 }
20042 dispatcher_update__ = Some(map_.next_value()?);
20043 }
20044 GeneratedField::MergeUpdate => {
20045 if merge_update__.is_some() {
20046 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
20047 }
20048 merge_update__ = Some(map_.next_value()?);
20049 }
20050 GeneratedField::ActorVnodeBitmapUpdate => {
20051 if actor_vnode_bitmap_update__.is_some() {
20052 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
20053 }
20054 actor_vnode_bitmap_update__ = Some(
20055 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
20056 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
20057 );
20058 }
20059 GeneratedField::DroppedActors => {
20060 if dropped_actors__.is_some() {
20061 return Err(serde::de::Error::duplicate_field("droppedActors"));
20062 }
20063 dropped_actors__ =
20064 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20065 .into_iter().map(|x| x.0).collect())
20066 ;
20067 }
20068 GeneratedField::ActorSplits => {
20069 if actor_splits__.is_some() {
20070 return Err(serde::de::Error::duplicate_field("actorSplits"));
20071 }
20072 actor_splits__ = Some(
20073 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
20074 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
20075 );
20076 }
20077 GeneratedField::ActorNewDispatchers => {
20078 if actor_new_dispatchers__.is_some() {
20079 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
20080 }
20081 actor_new_dispatchers__ = Some(
20082 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
20083 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
20084 );
20085 }
20086 GeneratedField::ActorCdcTableSnapshotSplits => {
20087 if actor_cdc_table_snapshot_splits__.is_some() {
20088 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
20089 }
20090 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
20091 }
20092 GeneratedField::SinkSchemaChange => {
20093 if sink_schema_change__.is_some() {
20094 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
20095 }
20096 sink_schema_change__ = Some(
20097 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
20098 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
20099 );
20100 }
20101 GeneratedField::SubscriptionsToDrop => {
20102 if subscriptions_to_drop__.is_some() {
20103 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
20104 }
20105 subscriptions_to_drop__ = Some(map_.next_value()?);
20106 }
20107 GeneratedField::IcebergPkIndexCompaction => {
20108 if iceberg_pk_index_compaction__.is_some() {
20109 return Err(serde::de::Error::duplicate_field("icebergPkIndexCompaction"));
20110 }
20111 iceberg_pk_index_compaction__ = map_.next_value()?;
20112 }
20113 }
20114 }
20115 Ok(UpdateMutation {
20116 dispatcher_update: dispatcher_update__.unwrap_or_default(),
20117 merge_update: merge_update__.unwrap_or_default(),
20118 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
20119 dropped_actors: dropped_actors__.unwrap_or_default(),
20120 actor_splits: actor_splits__.unwrap_or_default(),
20121 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
20122 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
20123 sink_schema_change: sink_schema_change__.unwrap_or_default(),
20124 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
20125 iceberg_pk_index_compaction: iceberg_pk_index_compaction__,
20126 })
20127 }
20128 }
20129 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
20130 }
20131}
20132impl serde::Serialize for update_mutation::DispatcherUpdate {
20133 #[allow(deprecated)]
20134 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20135 where
20136 S: serde::Serializer,
20137 {
20138 use serde::ser::SerializeStruct;
20139 let mut len = 0;
20140 if self.actor_id != 0 {
20141 len += 1;
20142 }
20143 if self.dispatcher_id != 0 {
20144 len += 1;
20145 }
20146 if self.hash_mapping.is_some() {
20147 len += 1;
20148 }
20149 if !self.added_downstream_actor_id.is_empty() {
20150 len += 1;
20151 }
20152 if !self.removed_downstream_actor_id.is_empty() {
20153 len += 1;
20154 }
20155 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
20156 if self.actor_id != 0 {
20157 struct_ser.serialize_field("actorId", &self.actor_id)?;
20158 }
20159 if self.dispatcher_id != 0 {
20160 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
20161 }
20162 if let Some(v) = self.hash_mapping.as_ref() {
20163 struct_ser.serialize_field("hashMapping", v)?;
20164 }
20165 if !self.added_downstream_actor_id.is_empty() {
20166 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
20167 }
20168 if !self.removed_downstream_actor_id.is_empty() {
20169 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
20170 }
20171 struct_ser.end()
20172 }
20173}
20174impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
20175 #[allow(deprecated)]
20176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20177 where
20178 D: serde::Deserializer<'de>,
20179 {
20180 const FIELDS: &[&str] = &[
20181 "actor_id",
20182 "actorId",
20183 "dispatcher_id",
20184 "dispatcherId",
20185 "hash_mapping",
20186 "hashMapping",
20187 "added_downstream_actor_id",
20188 "addedDownstreamActorId",
20189 "removed_downstream_actor_id",
20190 "removedDownstreamActorId",
20191 ];
20192
20193 #[allow(clippy::enum_variant_names)]
20194 enum GeneratedField {
20195 ActorId,
20196 DispatcherId,
20197 HashMapping,
20198 AddedDownstreamActorId,
20199 RemovedDownstreamActorId,
20200 }
20201 impl<'de> serde::Deserialize<'de> for GeneratedField {
20202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20203 where
20204 D: serde::Deserializer<'de>,
20205 {
20206 struct GeneratedVisitor;
20207
20208 impl serde::de::Visitor<'_> for GeneratedVisitor {
20209 type Value = GeneratedField;
20210
20211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20212 write!(formatter, "expected one of: {:?}", &FIELDS)
20213 }
20214
20215 #[allow(unused_variables)]
20216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20217 where
20218 E: serde::de::Error,
20219 {
20220 match value {
20221 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
20222 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
20223 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
20224 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
20225 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
20226 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20227 }
20228 }
20229 }
20230 deserializer.deserialize_identifier(GeneratedVisitor)
20231 }
20232 }
20233 struct GeneratedVisitor;
20234 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20235 type Value = update_mutation::DispatcherUpdate;
20236
20237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20238 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
20239 }
20240
20241 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
20242 where
20243 V: serde::de::MapAccess<'de>,
20244 {
20245 let mut actor_id__ = None;
20246 let mut dispatcher_id__ = None;
20247 let mut hash_mapping__ = None;
20248 let mut added_downstream_actor_id__ = None;
20249 let mut removed_downstream_actor_id__ = None;
20250 while let Some(k) = map_.next_key()? {
20251 match k {
20252 GeneratedField::ActorId => {
20253 if actor_id__.is_some() {
20254 return Err(serde::de::Error::duplicate_field("actorId"));
20255 }
20256 actor_id__ =
20257 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20258 ;
20259 }
20260 GeneratedField::DispatcherId => {
20261 if dispatcher_id__.is_some() {
20262 return Err(serde::de::Error::duplicate_field("dispatcherId"));
20263 }
20264 dispatcher_id__ =
20265 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20266 ;
20267 }
20268 GeneratedField::HashMapping => {
20269 if hash_mapping__.is_some() {
20270 return Err(serde::de::Error::duplicate_field("hashMapping"));
20271 }
20272 hash_mapping__ = map_.next_value()?;
20273 }
20274 GeneratedField::AddedDownstreamActorId => {
20275 if added_downstream_actor_id__.is_some() {
20276 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
20277 }
20278 added_downstream_actor_id__ =
20279 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20280 .into_iter().map(|x| x.0).collect())
20281 ;
20282 }
20283 GeneratedField::RemovedDownstreamActorId => {
20284 if removed_downstream_actor_id__.is_some() {
20285 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
20286 }
20287 removed_downstream_actor_id__ =
20288 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20289 .into_iter().map(|x| x.0).collect())
20290 ;
20291 }
20292 }
20293 }
20294 Ok(update_mutation::DispatcherUpdate {
20295 actor_id: actor_id__.unwrap_or_default(),
20296 dispatcher_id: dispatcher_id__.unwrap_or_default(),
20297 hash_mapping: hash_mapping__,
20298 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
20299 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
20300 })
20301 }
20302 }
20303 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
20304 }
20305}
20306impl serde::Serialize for update_mutation::MergeUpdate {
20307 #[allow(deprecated)]
20308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20309 where
20310 S: serde::Serializer,
20311 {
20312 use serde::ser::SerializeStruct;
20313 let mut len = 0;
20314 if self.actor_id != 0 {
20315 len += 1;
20316 }
20317 if self.upstream_fragment_id != 0 {
20318 len += 1;
20319 }
20320 if self.new_upstream_fragment_id.is_some() {
20321 len += 1;
20322 }
20323 if !self.added_upstream_actors.is_empty() {
20324 len += 1;
20325 }
20326 if !self.removed_upstream_actor_id.is_empty() {
20327 len += 1;
20328 }
20329 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
20330 if self.actor_id != 0 {
20331 struct_ser.serialize_field("actorId", &self.actor_id)?;
20332 }
20333 if self.upstream_fragment_id != 0 {
20334 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
20335 }
20336 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
20337 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
20338 }
20339 if !self.added_upstream_actors.is_empty() {
20340 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
20341 }
20342 if !self.removed_upstream_actor_id.is_empty() {
20343 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
20344 }
20345 struct_ser.end()
20346 }
20347}
20348impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
20349 #[allow(deprecated)]
20350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20351 where
20352 D: serde::Deserializer<'de>,
20353 {
20354 const FIELDS: &[&str] = &[
20355 "actor_id",
20356 "actorId",
20357 "upstream_fragment_id",
20358 "upstreamFragmentId",
20359 "new_upstream_fragment_id",
20360 "newUpstreamFragmentId",
20361 "added_upstream_actors",
20362 "addedUpstreamActors",
20363 "removed_upstream_actor_id",
20364 "removedUpstreamActorId",
20365 ];
20366
20367 #[allow(clippy::enum_variant_names)]
20368 enum GeneratedField {
20369 ActorId,
20370 UpstreamFragmentId,
20371 NewUpstreamFragmentId,
20372 AddedUpstreamActors,
20373 RemovedUpstreamActorId,
20374 }
20375 impl<'de> serde::Deserialize<'de> for GeneratedField {
20376 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20377 where
20378 D: serde::Deserializer<'de>,
20379 {
20380 struct GeneratedVisitor;
20381
20382 impl serde::de::Visitor<'_> for GeneratedVisitor {
20383 type Value = GeneratedField;
20384
20385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20386 write!(formatter, "expected one of: {:?}", &FIELDS)
20387 }
20388
20389 #[allow(unused_variables)]
20390 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20391 where
20392 E: serde::de::Error,
20393 {
20394 match value {
20395 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
20396 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
20397 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
20398 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
20399 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
20400 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20401 }
20402 }
20403 }
20404 deserializer.deserialize_identifier(GeneratedVisitor)
20405 }
20406 }
20407 struct GeneratedVisitor;
20408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20409 type Value = update_mutation::MergeUpdate;
20410
20411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20412 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
20413 }
20414
20415 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
20416 where
20417 V: serde::de::MapAccess<'de>,
20418 {
20419 let mut actor_id__ = None;
20420 let mut upstream_fragment_id__ = None;
20421 let mut new_upstream_fragment_id__ = None;
20422 let mut added_upstream_actors__ = None;
20423 let mut removed_upstream_actor_id__ = None;
20424 while let Some(k) = map_.next_key()? {
20425 match k {
20426 GeneratedField::ActorId => {
20427 if actor_id__.is_some() {
20428 return Err(serde::de::Error::duplicate_field("actorId"));
20429 }
20430 actor_id__ =
20431 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20432 ;
20433 }
20434 GeneratedField::UpstreamFragmentId => {
20435 if upstream_fragment_id__.is_some() {
20436 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
20437 }
20438 upstream_fragment_id__ =
20439 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20440 ;
20441 }
20442 GeneratedField::NewUpstreamFragmentId => {
20443 if new_upstream_fragment_id__.is_some() {
20444 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
20445 }
20446 new_upstream_fragment_id__ =
20447 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
20448 ;
20449 }
20450 GeneratedField::AddedUpstreamActors => {
20451 if added_upstream_actors__.is_some() {
20452 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
20453 }
20454 added_upstream_actors__ = Some(map_.next_value()?);
20455 }
20456 GeneratedField::RemovedUpstreamActorId => {
20457 if removed_upstream_actor_id__.is_some() {
20458 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
20459 }
20460 removed_upstream_actor_id__ =
20461 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20462 .into_iter().map(|x| x.0).collect())
20463 ;
20464 }
20465 }
20466 }
20467 Ok(update_mutation::MergeUpdate {
20468 actor_id: actor_id__.unwrap_or_default(),
20469 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
20470 new_upstream_fragment_id: new_upstream_fragment_id__,
20471 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
20472 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
20473 })
20474 }
20475 }
20476 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
20477 }
20478}
20479impl serde::Serialize for UpstreamSinkInfo {
20480 #[allow(deprecated)]
20481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20482 where
20483 S: serde::Serializer,
20484 {
20485 use serde::ser::SerializeStruct;
20486 let mut len = 0;
20487 if self.upstream_fragment_id != 0 {
20488 len += 1;
20489 }
20490 if !self.sink_output_schema.is_empty() {
20491 len += 1;
20492 }
20493 if !self.project_exprs.is_empty() {
20494 len += 1;
20495 }
20496 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
20497 if self.upstream_fragment_id != 0 {
20498 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
20499 }
20500 if !self.sink_output_schema.is_empty() {
20501 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
20502 }
20503 if !self.project_exprs.is_empty() {
20504 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
20505 }
20506 struct_ser.end()
20507 }
20508}
20509impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
20510 #[allow(deprecated)]
20511 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20512 where
20513 D: serde::Deserializer<'de>,
20514 {
20515 const FIELDS: &[&str] = &[
20516 "upstream_fragment_id",
20517 "upstreamFragmentId",
20518 "sink_output_schema",
20519 "sinkOutputSchema",
20520 "project_exprs",
20521 "projectExprs",
20522 ];
20523
20524 #[allow(clippy::enum_variant_names)]
20525 enum GeneratedField {
20526 UpstreamFragmentId,
20527 SinkOutputSchema,
20528 ProjectExprs,
20529 }
20530 impl<'de> serde::Deserialize<'de> for GeneratedField {
20531 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20532 where
20533 D: serde::Deserializer<'de>,
20534 {
20535 struct GeneratedVisitor;
20536
20537 impl serde::de::Visitor<'_> for GeneratedVisitor {
20538 type Value = GeneratedField;
20539
20540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20541 write!(formatter, "expected one of: {:?}", &FIELDS)
20542 }
20543
20544 #[allow(unused_variables)]
20545 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20546 where
20547 E: serde::de::Error,
20548 {
20549 match value {
20550 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
20551 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
20552 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
20553 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20554 }
20555 }
20556 }
20557 deserializer.deserialize_identifier(GeneratedVisitor)
20558 }
20559 }
20560 struct GeneratedVisitor;
20561 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20562 type Value = UpstreamSinkInfo;
20563
20564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20565 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
20566 }
20567
20568 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
20569 where
20570 V: serde::de::MapAccess<'de>,
20571 {
20572 let mut upstream_fragment_id__ = None;
20573 let mut sink_output_schema__ = None;
20574 let mut project_exprs__ = None;
20575 while let Some(k) = map_.next_key()? {
20576 match k {
20577 GeneratedField::UpstreamFragmentId => {
20578 if upstream_fragment_id__.is_some() {
20579 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
20580 }
20581 upstream_fragment_id__ =
20582 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20583 ;
20584 }
20585 GeneratedField::SinkOutputSchema => {
20586 if sink_output_schema__.is_some() {
20587 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
20588 }
20589 sink_output_schema__ = Some(map_.next_value()?);
20590 }
20591 GeneratedField::ProjectExprs => {
20592 if project_exprs__.is_some() {
20593 return Err(serde::de::Error::duplicate_field("projectExprs"));
20594 }
20595 project_exprs__ = Some(map_.next_value()?);
20596 }
20597 }
20598 }
20599 Ok(UpstreamSinkInfo {
20600 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
20601 sink_output_schema: sink_output_schema__.unwrap_or_default(),
20602 project_exprs: project_exprs__.unwrap_or_default(),
20603 })
20604 }
20605 }
20606 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
20607 }
20608}
20609impl serde::Serialize for UpstreamSinkUnionNode {
20610 #[allow(deprecated)]
20611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20612 where
20613 S: serde::Serializer,
20614 {
20615 use serde::ser::SerializeStruct;
20616 let mut len = 0;
20617 if !self.init_upstreams.is_empty() {
20618 len += 1;
20619 }
20620 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
20621 if !self.init_upstreams.is_empty() {
20622 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
20623 }
20624 struct_ser.end()
20625 }
20626}
20627impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
20628 #[allow(deprecated)]
20629 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20630 where
20631 D: serde::Deserializer<'de>,
20632 {
20633 const FIELDS: &[&str] = &[
20634 "init_upstreams",
20635 "initUpstreams",
20636 ];
20637
20638 #[allow(clippy::enum_variant_names)]
20639 enum GeneratedField {
20640 InitUpstreams,
20641 }
20642 impl<'de> serde::Deserialize<'de> for GeneratedField {
20643 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20644 where
20645 D: serde::Deserializer<'de>,
20646 {
20647 struct GeneratedVisitor;
20648
20649 impl serde::de::Visitor<'_> for GeneratedVisitor {
20650 type Value = GeneratedField;
20651
20652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20653 write!(formatter, "expected one of: {:?}", &FIELDS)
20654 }
20655
20656 #[allow(unused_variables)]
20657 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20658 where
20659 E: serde::de::Error,
20660 {
20661 match value {
20662 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
20663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20664 }
20665 }
20666 }
20667 deserializer.deserialize_identifier(GeneratedVisitor)
20668 }
20669 }
20670 struct GeneratedVisitor;
20671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20672 type Value = UpstreamSinkUnionNode;
20673
20674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20675 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
20676 }
20677
20678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
20679 where
20680 V: serde::de::MapAccess<'de>,
20681 {
20682 let mut init_upstreams__ = None;
20683 while let Some(k) = map_.next_key()? {
20684 match k {
20685 GeneratedField::InitUpstreams => {
20686 if init_upstreams__.is_some() {
20687 return Err(serde::de::Error::duplicate_field("initUpstreams"));
20688 }
20689 init_upstreams__ = Some(map_.next_value()?);
20690 }
20691 }
20692 }
20693 Ok(UpstreamSinkUnionNode {
20694 init_upstreams: init_upstreams__.unwrap_or_default(),
20695 })
20696 }
20697 }
20698 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
20699 }
20700}
20701impl serde::Serialize for ValuesNode {
20702 #[allow(deprecated)]
20703 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20704 where
20705 S: serde::Serializer,
20706 {
20707 use serde::ser::SerializeStruct;
20708 let mut len = 0;
20709 if !self.tuples.is_empty() {
20710 len += 1;
20711 }
20712 if !self.fields.is_empty() {
20713 len += 1;
20714 }
20715 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
20716 if !self.tuples.is_empty() {
20717 struct_ser.serialize_field("tuples", &self.tuples)?;
20718 }
20719 if !self.fields.is_empty() {
20720 struct_ser.serialize_field("fields", &self.fields)?;
20721 }
20722 struct_ser.end()
20723 }
20724}
20725impl<'de> serde::Deserialize<'de> for ValuesNode {
20726 #[allow(deprecated)]
20727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20728 where
20729 D: serde::Deserializer<'de>,
20730 {
20731 const FIELDS: &[&str] = &[
20732 "tuples",
20733 "fields",
20734 ];
20735
20736 #[allow(clippy::enum_variant_names)]
20737 enum GeneratedField {
20738 Tuples,
20739 Fields,
20740 }
20741 impl<'de> serde::Deserialize<'de> for GeneratedField {
20742 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20743 where
20744 D: serde::Deserializer<'de>,
20745 {
20746 struct GeneratedVisitor;
20747
20748 impl serde::de::Visitor<'_> for GeneratedVisitor {
20749 type Value = GeneratedField;
20750
20751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20752 write!(formatter, "expected one of: {:?}", &FIELDS)
20753 }
20754
20755 #[allow(unused_variables)]
20756 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20757 where
20758 E: serde::de::Error,
20759 {
20760 match value {
20761 "tuples" => Ok(GeneratedField::Tuples),
20762 "fields" => Ok(GeneratedField::Fields),
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 = ValuesNode;
20773
20774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20775 formatter.write_str("struct stream_plan.ValuesNode")
20776 }
20777
20778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
20779 where
20780 V: serde::de::MapAccess<'de>,
20781 {
20782 let mut tuples__ = None;
20783 let mut fields__ = None;
20784 while let Some(k) = map_.next_key()? {
20785 match k {
20786 GeneratedField::Tuples => {
20787 if tuples__.is_some() {
20788 return Err(serde::de::Error::duplicate_field("tuples"));
20789 }
20790 tuples__ = Some(map_.next_value()?);
20791 }
20792 GeneratedField::Fields => {
20793 if fields__.is_some() {
20794 return Err(serde::de::Error::duplicate_field("fields"));
20795 }
20796 fields__ = Some(map_.next_value()?);
20797 }
20798 }
20799 }
20800 Ok(ValuesNode {
20801 tuples: tuples__.unwrap_or_default(),
20802 fields: fields__.unwrap_or_default(),
20803 })
20804 }
20805 }
20806 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
20807 }
20808}
20809impl serde::Serialize for values_node::ExprTuple {
20810 #[allow(deprecated)]
20811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20812 where
20813 S: serde::Serializer,
20814 {
20815 use serde::ser::SerializeStruct;
20816 let mut len = 0;
20817 if !self.cells.is_empty() {
20818 len += 1;
20819 }
20820 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
20821 if !self.cells.is_empty() {
20822 struct_ser.serialize_field("cells", &self.cells)?;
20823 }
20824 struct_ser.end()
20825 }
20826}
20827impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
20828 #[allow(deprecated)]
20829 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20830 where
20831 D: serde::Deserializer<'de>,
20832 {
20833 const FIELDS: &[&str] = &[
20834 "cells",
20835 ];
20836
20837 #[allow(clippy::enum_variant_names)]
20838 enum GeneratedField {
20839 Cells,
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 "cells" => Ok(GeneratedField::Cells),
20862 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20863 }
20864 }
20865 }
20866 deserializer.deserialize_identifier(GeneratedVisitor)
20867 }
20868 }
20869 struct GeneratedVisitor;
20870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20871 type Value = values_node::ExprTuple;
20872
20873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20874 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
20875 }
20876
20877 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
20878 where
20879 V: serde::de::MapAccess<'de>,
20880 {
20881 let mut cells__ = None;
20882 while let Some(k) = map_.next_key()? {
20883 match k {
20884 GeneratedField::Cells => {
20885 if cells__.is_some() {
20886 return Err(serde::de::Error::duplicate_field("cells"));
20887 }
20888 cells__ = Some(map_.next_value()?);
20889 }
20890 }
20891 }
20892 Ok(values_node::ExprTuple {
20893 cells: cells__.unwrap_or_default(),
20894 })
20895 }
20896 }
20897 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
20898 }
20899}
20900impl serde::Serialize for VectorIndexLookupJoinNode {
20901 #[allow(deprecated)]
20902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20903 where
20904 S: serde::Serializer,
20905 {
20906 use serde::ser::SerializeStruct;
20907 let mut len = 0;
20908 if self.reader_desc.is_some() {
20909 len += 1;
20910 }
20911 if self.vector_column_idx != 0 {
20912 len += 1;
20913 }
20914 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
20915 if let Some(v) = self.reader_desc.as_ref() {
20916 struct_ser.serialize_field("readerDesc", v)?;
20917 }
20918 if self.vector_column_idx != 0 {
20919 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
20920 }
20921 struct_ser.end()
20922 }
20923}
20924impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
20925 #[allow(deprecated)]
20926 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20927 where
20928 D: serde::Deserializer<'de>,
20929 {
20930 const FIELDS: &[&str] = &[
20931 "reader_desc",
20932 "readerDesc",
20933 "vector_column_idx",
20934 "vectorColumnIdx",
20935 ];
20936
20937 #[allow(clippy::enum_variant_names)]
20938 enum GeneratedField {
20939 ReaderDesc,
20940 VectorColumnIdx,
20941 }
20942 impl<'de> serde::Deserialize<'de> for GeneratedField {
20943 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20944 where
20945 D: serde::Deserializer<'de>,
20946 {
20947 struct GeneratedVisitor;
20948
20949 impl serde::de::Visitor<'_> for GeneratedVisitor {
20950 type Value = GeneratedField;
20951
20952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20953 write!(formatter, "expected one of: {:?}", &FIELDS)
20954 }
20955
20956 #[allow(unused_variables)]
20957 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20958 where
20959 E: serde::de::Error,
20960 {
20961 match value {
20962 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
20963 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
20964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20965 }
20966 }
20967 }
20968 deserializer.deserialize_identifier(GeneratedVisitor)
20969 }
20970 }
20971 struct GeneratedVisitor;
20972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20973 type Value = VectorIndexLookupJoinNode;
20974
20975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20976 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
20977 }
20978
20979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
20980 where
20981 V: serde::de::MapAccess<'de>,
20982 {
20983 let mut reader_desc__ = None;
20984 let mut vector_column_idx__ = None;
20985 while let Some(k) = map_.next_key()? {
20986 match k {
20987 GeneratedField::ReaderDesc => {
20988 if reader_desc__.is_some() {
20989 return Err(serde::de::Error::duplicate_field("readerDesc"));
20990 }
20991 reader_desc__ = map_.next_value()?;
20992 }
20993 GeneratedField::VectorColumnIdx => {
20994 if vector_column_idx__.is_some() {
20995 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
20996 }
20997 vector_column_idx__ =
20998 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20999 ;
21000 }
21001 }
21002 }
21003 Ok(VectorIndexLookupJoinNode {
21004 reader_desc: reader_desc__,
21005 vector_column_idx: vector_column_idx__.unwrap_or_default(),
21006 })
21007 }
21008 }
21009 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
21010 }
21011}
21012impl serde::Serialize for VectorIndexWriteNode {
21013 #[allow(deprecated)]
21014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
21015 where
21016 S: serde::Serializer,
21017 {
21018 use serde::ser::SerializeStruct;
21019 let mut len = 0;
21020 if self.table.is_some() {
21021 len += 1;
21022 }
21023 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
21024 if let Some(v) = self.table.as_ref() {
21025 struct_ser.serialize_field("table", v)?;
21026 }
21027 struct_ser.end()
21028 }
21029}
21030impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
21031 #[allow(deprecated)]
21032 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
21033 where
21034 D: serde::Deserializer<'de>,
21035 {
21036 const FIELDS: &[&str] = &[
21037 "table",
21038 ];
21039
21040 #[allow(clippy::enum_variant_names)]
21041 enum GeneratedField {
21042 Table,
21043 }
21044 impl<'de> serde::Deserialize<'de> for GeneratedField {
21045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
21046 where
21047 D: serde::Deserializer<'de>,
21048 {
21049 struct GeneratedVisitor;
21050
21051 impl serde::de::Visitor<'_> for GeneratedVisitor {
21052 type Value = GeneratedField;
21053
21054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21055 write!(formatter, "expected one of: {:?}", &FIELDS)
21056 }
21057
21058 #[allow(unused_variables)]
21059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
21060 where
21061 E: serde::de::Error,
21062 {
21063 match value {
21064 "table" => Ok(GeneratedField::Table),
21065 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
21066 }
21067 }
21068 }
21069 deserializer.deserialize_identifier(GeneratedVisitor)
21070 }
21071 }
21072 struct GeneratedVisitor;
21073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
21074 type Value = VectorIndexWriteNode;
21075
21076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21077 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
21078 }
21079
21080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
21081 where
21082 V: serde::de::MapAccess<'de>,
21083 {
21084 let mut table__ = None;
21085 while let Some(k) = map_.next_key()? {
21086 match k {
21087 GeneratedField::Table => {
21088 if table__.is_some() {
21089 return Err(serde::de::Error::duplicate_field("table"));
21090 }
21091 table__ = map_.next_value()?;
21092 }
21093 }
21094 }
21095 Ok(VectorIndexWriteNode {
21096 table: table__,
21097 })
21098 }
21099 }
21100 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
21101 }
21102}
21103impl serde::Serialize for Watermark {
21104 #[allow(deprecated)]
21105 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
21106 where
21107 S: serde::Serializer,
21108 {
21109 use serde::ser::SerializeStruct;
21110 let mut len = 0;
21111 if self.column.is_some() {
21112 len += 1;
21113 }
21114 if self.val.is_some() {
21115 len += 1;
21116 }
21117 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
21118 if let Some(v) = self.column.as_ref() {
21119 struct_ser.serialize_field("column", v)?;
21120 }
21121 if let Some(v) = self.val.as_ref() {
21122 struct_ser.serialize_field("val", v)?;
21123 }
21124 struct_ser.end()
21125 }
21126}
21127impl<'de> serde::Deserialize<'de> for Watermark {
21128 #[allow(deprecated)]
21129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
21130 where
21131 D: serde::Deserializer<'de>,
21132 {
21133 const FIELDS: &[&str] = &[
21134 "column",
21135 "val",
21136 ];
21137
21138 #[allow(clippy::enum_variant_names)]
21139 enum GeneratedField {
21140 Column,
21141 Val,
21142 }
21143 impl<'de> serde::Deserialize<'de> for GeneratedField {
21144 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
21145 where
21146 D: serde::Deserializer<'de>,
21147 {
21148 struct GeneratedVisitor;
21149
21150 impl serde::de::Visitor<'_> for GeneratedVisitor {
21151 type Value = GeneratedField;
21152
21153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21154 write!(formatter, "expected one of: {:?}", &FIELDS)
21155 }
21156
21157 #[allow(unused_variables)]
21158 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
21159 where
21160 E: serde::de::Error,
21161 {
21162 match value {
21163 "column" => Ok(GeneratedField::Column),
21164 "val" => Ok(GeneratedField::Val),
21165 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
21166 }
21167 }
21168 }
21169 deserializer.deserialize_identifier(GeneratedVisitor)
21170 }
21171 }
21172 struct GeneratedVisitor;
21173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
21174 type Value = Watermark;
21175
21176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21177 formatter.write_str("struct stream_plan.Watermark")
21178 }
21179
21180 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
21181 where
21182 V: serde::de::MapAccess<'de>,
21183 {
21184 let mut column__ = None;
21185 let mut val__ = None;
21186 while let Some(k) = map_.next_key()? {
21187 match k {
21188 GeneratedField::Column => {
21189 if column__.is_some() {
21190 return Err(serde::de::Error::duplicate_field("column"));
21191 }
21192 column__ = map_.next_value()?;
21193 }
21194 GeneratedField::Val => {
21195 if val__.is_some() {
21196 return Err(serde::de::Error::duplicate_field("val"));
21197 }
21198 val__ = map_.next_value()?;
21199 }
21200 }
21201 }
21202 Ok(Watermark {
21203 column: column__,
21204 val: val__,
21205 })
21206 }
21207 }
21208 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
21209 }
21210}
21211impl serde::Serialize for WatermarkFilterNode {
21212 #[allow(deprecated)]
21213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
21214 where
21215 S: serde::Serializer,
21216 {
21217 use serde::ser::SerializeStruct;
21218 let mut len = 0;
21219 if !self.watermark_descs.is_empty() {
21220 len += 1;
21221 }
21222 if !self.tables.is_empty() {
21223 len += 1;
21224 }
21225 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
21226 if !self.watermark_descs.is_empty() {
21227 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
21228 }
21229 if !self.tables.is_empty() {
21230 struct_ser.serialize_field("tables", &self.tables)?;
21231 }
21232 struct_ser.end()
21233 }
21234}
21235impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
21236 #[allow(deprecated)]
21237 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
21238 where
21239 D: serde::Deserializer<'de>,
21240 {
21241 const FIELDS: &[&str] = &[
21242 "watermark_descs",
21243 "watermarkDescs",
21244 "tables",
21245 ];
21246
21247 #[allow(clippy::enum_variant_names)]
21248 enum GeneratedField {
21249 WatermarkDescs,
21250 Tables,
21251 }
21252 impl<'de> serde::Deserialize<'de> for GeneratedField {
21253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
21254 where
21255 D: serde::Deserializer<'de>,
21256 {
21257 struct GeneratedVisitor;
21258
21259 impl serde::de::Visitor<'_> for GeneratedVisitor {
21260 type Value = GeneratedField;
21261
21262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21263 write!(formatter, "expected one of: {:?}", &FIELDS)
21264 }
21265
21266 #[allow(unused_variables)]
21267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
21268 where
21269 E: serde::de::Error,
21270 {
21271 match value {
21272 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
21273 "tables" => Ok(GeneratedField::Tables),
21274 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
21275 }
21276 }
21277 }
21278 deserializer.deserialize_identifier(GeneratedVisitor)
21279 }
21280 }
21281 struct GeneratedVisitor;
21282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
21283 type Value = WatermarkFilterNode;
21284
21285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21286 formatter.write_str("struct stream_plan.WatermarkFilterNode")
21287 }
21288
21289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
21290 where
21291 V: serde::de::MapAccess<'de>,
21292 {
21293 let mut watermark_descs__ = None;
21294 let mut tables__ = None;
21295 while let Some(k) = map_.next_key()? {
21296 match k {
21297 GeneratedField::WatermarkDescs => {
21298 if watermark_descs__.is_some() {
21299 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
21300 }
21301 watermark_descs__ = Some(map_.next_value()?);
21302 }
21303 GeneratedField::Tables => {
21304 if tables__.is_some() {
21305 return Err(serde::de::Error::duplicate_field("tables"));
21306 }
21307 tables__ = Some(map_.next_value()?);
21308 }
21309 }
21310 }
21311 Ok(WatermarkFilterNode {
21312 watermark_descs: watermark_descs__.unwrap_or_default(),
21313 tables: tables__.unwrap_or_default(),
21314 })
21315 }
21316 }
21317 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
21318 }
21319}