1use crate::batch_plan::*;
2impl serde::Serialize for AzblobFileScanNode {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if !self.columns.is_empty() {
11 len += 1;
12 }
13 if self.file_format != 0 {
14 len += 1;
15 }
16 if !self.account_name.is_empty() {
17 len += 1;
18 }
19 if !self.account_key.is_empty() {
20 len += 1;
21 }
22 if !self.endpoint.is_empty() {
23 len += 1;
24 }
25 if !self.file_location.is_empty() {
26 len += 1;
27 }
28 let mut struct_ser = serializer.serialize_struct("batch_plan.AzblobFileScanNode", len)?;
29 if !self.columns.is_empty() {
30 struct_ser.serialize_field("columns", &self.columns)?;
31 }
32 if self.file_format != 0 {
33 let v = azblob_file_scan_node::FileFormat::try_from(self.file_format)
34 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.file_format)))?;
35 struct_ser.serialize_field("fileFormat", &v)?;
36 }
37 if !self.account_name.is_empty() {
38 struct_ser.serialize_field("accountName", &self.account_name)?;
39 }
40 if !self.account_key.is_empty() {
41 struct_ser.serialize_field("accountKey", &self.account_key)?;
42 }
43 if !self.endpoint.is_empty() {
44 struct_ser.serialize_field("endpoint", &self.endpoint)?;
45 }
46 if !self.file_location.is_empty() {
47 struct_ser.serialize_field("fileLocation", &self.file_location)?;
48 }
49 struct_ser.end()
50 }
51}
52impl<'de> serde::Deserialize<'de> for AzblobFileScanNode {
53 #[allow(deprecated)]
54 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
55 where
56 D: serde::Deserializer<'de>,
57 {
58 const FIELDS: &[&str] = &[
59 "columns",
60 "file_format",
61 "fileFormat",
62 "account_name",
63 "accountName",
64 "account_key",
65 "accountKey",
66 "endpoint",
67 "file_location",
68 "fileLocation",
69 ];
70
71 #[allow(clippy::enum_variant_names)]
72 enum GeneratedField {
73 Columns,
74 FileFormat,
75 AccountName,
76 AccountKey,
77 Endpoint,
78 FileLocation,
79 }
80 impl<'de> serde::Deserialize<'de> for GeneratedField {
81 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
82 where
83 D: serde::Deserializer<'de>,
84 {
85 struct GeneratedVisitor;
86
87 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
88 type Value = GeneratedField;
89
90 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
91 write!(formatter, "expected one of: {:?}", &FIELDS)
92 }
93
94 #[allow(unused_variables)]
95 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
96 where
97 E: serde::de::Error,
98 {
99 match value {
100 "columns" => Ok(GeneratedField::Columns),
101 "fileFormat" | "file_format" => Ok(GeneratedField::FileFormat),
102 "accountName" | "account_name" => Ok(GeneratedField::AccountName),
103 "accountKey" | "account_key" => Ok(GeneratedField::AccountKey),
104 "endpoint" => Ok(GeneratedField::Endpoint),
105 "fileLocation" | "file_location" => Ok(GeneratedField::FileLocation),
106 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
107 }
108 }
109 }
110 deserializer.deserialize_identifier(GeneratedVisitor)
111 }
112 }
113 struct GeneratedVisitor;
114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
115 type Value = AzblobFileScanNode;
116
117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
118 formatter.write_str("struct batch_plan.AzblobFileScanNode")
119 }
120
121 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AzblobFileScanNode, V::Error>
122 where
123 V: serde::de::MapAccess<'de>,
124 {
125 let mut columns__ = None;
126 let mut file_format__ = None;
127 let mut account_name__ = None;
128 let mut account_key__ = None;
129 let mut endpoint__ = None;
130 let mut file_location__ = None;
131 while let Some(k) = map_.next_key()? {
132 match k {
133 GeneratedField::Columns => {
134 if columns__.is_some() {
135 return Err(serde::de::Error::duplicate_field("columns"));
136 }
137 columns__ = Some(map_.next_value()?);
138 }
139 GeneratedField::FileFormat => {
140 if file_format__.is_some() {
141 return Err(serde::de::Error::duplicate_field("fileFormat"));
142 }
143 file_format__ = Some(map_.next_value::<azblob_file_scan_node::FileFormat>()? as i32);
144 }
145 GeneratedField::AccountName => {
146 if account_name__.is_some() {
147 return Err(serde::de::Error::duplicate_field("accountName"));
148 }
149 account_name__ = Some(map_.next_value()?);
150 }
151 GeneratedField::AccountKey => {
152 if account_key__.is_some() {
153 return Err(serde::de::Error::duplicate_field("accountKey"));
154 }
155 account_key__ = Some(map_.next_value()?);
156 }
157 GeneratedField::Endpoint => {
158 if endpoint__.is_some() {
159 return Err(serde::de::Error::duplicate_field("endpoint"));
160 }
161 endpoint__ = Some(map_.next_value()?);
162 }
163 GeneratedField::FileLocation => {
164 if file_location__.is_some() {
165 return Err(serde::de::Error::duplicate_field("fileLocation"));
166 }
167 file_location__ = Some(map_.next_value()?);
168 }
169 }
170 }
171 Ok(AzblobFileScanNode {
172 columns: columns__.unwrap_or_default(),
173 file_format: file_format__.unwrap_or_default(),
174 account_name: account_name__.unwrap_or_default(),
175 account_key: account_key__.unwrap_or_default(),
176 endpoint: endpoint__.unwrap_or_default(),
177 file_location: file_location__.unwrap_or_default(),
178 })
179 }
180 }
181 deserializer.deserialize_struct("batch_plan.AzblobFileScanNode", FIELDS, GeneratedVisitor)
182 }
183}
184impl serde::Serialize for azblob_file_scan_node::FileFormat {
185 #[allow(deprecated)]
186 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
187 where
188 S: serde::Serializer,
189 {
190 let variant = match self {
191 Self::Unspecified => "FILE_FORMAT_UNSPECIFIED",
192 Self::Parquet => "PARQUET",
193 };
194 serializer.serialize_str(variant)
195 }
196}
197impl<'de> serde::Deserialize<'de> for azblob_file_scan_node::FileFormat {
198 #[allow(deprecated)]
199 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
200 where
201 D: serde::Deserializer<'de>,
202 {
203 const FIELDS: &[&str] = &[
204 "FILE_FORMAT_UNSPECIFIED",
205 "PARQUET",
206 ];
207
208 struct GeneratedVisitor;
209
210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
211 type Value = azblob_file_scan_node::FileFormat;
212
213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
214 write!(formatter, "expected one of: {:?}", &FIELDS)
215 }
216
217 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
218 where
219 E: serde::de::Error,
220 {
221 i32::try_from(v)
222 .ok()
223 .and_then(|x| x.try_into().ok())
224 .ok_or_else(|| {
225 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
226 })
227 }
228
229 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
230 where
231 E: serde::de::Error,
232 {
233 i32::try_from(v)
234 .ok()
235 .and_then(|x| x.try_into().ok())
236 .ok_or_else(|| {
237 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
238 })
239 }
240
241 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
242 where
243 E: serde::de::Error,
244 {
245 match value {
246 "FILE_FORMAT_UNSPECIFIED" => Ok(azblob_file_scan_node::FileFormat::Unspecified),
247 "PARQUET" => Ok(azblob_file_scan_node::FileFormat::Parquet),
248 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
249 }
250 }
251 }
252 deserializer.deserialize_any(GeneratedVisitor)
253 }
254}
255impl serde::Serialize for DeleteNode {
256 #[allow(deprecated)]
257 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
258 where
259 S: serde::Serializer,
260 {
261 use serde::ser::SerializeStruct;
262 let mut len = 0;
263 if self.table_id != 0 {
264 len += 1;
265 }
266 if self.table_version_id != 0 {
267 len += 1;
268 }
269 if self.returning {
270 len += 1;
271 }
272 if self.session_id != 0 {
273 len += 1;
274 }
275 let mut struct_ser = serializer.serialize_struct("batch_plan.DeleteNode", len)?;
276 if self.table_id != 0 {
277 struct_ser.serialize_field("tableId", &self.table_id)?;
278 }
279 if self.table_version_id != 0 {
280 #[allow(clippy::needless_borrow)]
281 #[allow(clippy::needless_borrows_for_generic_args)]
282 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
283 }
284 if self.returning {
285 struct_ser.serialize_field("returning", &self.returning)?;
286 }
287 if self.session_id != 0 {
288 struct_ser.serialize_field("sessionId", &self.session_id)?;
289 }
290 struct_ser.end()
291 }
292}
293impl<'de> serde::Deserialize<'de> for DeleteNode {
294 #[allow(deprecated)]
295 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
296 where
297 D: serde::Deserializer<'de>,
298 {
299 const FIELDS: &[&str] = &[
300 "table_id",
301 "tableId",
302 "table_version_id",
303 "tableVersionId",
304 "returning",
305 "session_id",
306 "sessionId",
307 ];
308
309 #[allow(clippy::enum_variant_names)]
310 enum GeneratedField {
311 TableId,
312 TableVersionId,
313 Returning,
314 SessionId,
315 }
316 impl<'de> serde::Deserialize<'de> for GeneratedField {
317 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
318 where
319 D: serde::Deserializer<'de>,
320 {
321 struct GeneratedVisitor;
322
323 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
324 type Value = GeneratedField;
325
326 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
327 write!(formatter, "expected one of: {:?}", &FIELDS)
328 }
329
330 #[allow(unused_variables)]
331 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
332 where
333 E: serde::de::Error,
334 {
335 match value {
336 "tableId" | "table_id" => Ok(GeneratedField::TableId),
337 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
338 "returning" => Ok(GeneratedField::Returning),
339 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
340 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
341 }
342 }
343 }
344 deserializer.deserialize_identifier(GeneratedVisitor)
345 }
346 }
347 struct GeneratedVisitor;
348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
349 type Value = DeleteNode;
350
351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
352 formatter.write_str("struct batch_plan.DeleteNode")
353 }
354
355 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteNode, V::Error>
356 where
357 V: serde::de::MapAccess<'de>,
358 {
359 let mut table_id__ = None;
360 let mut table_version_id__ = None;
361 let mut returning__ = None;
362 let mut session_id__ = None;
363 while let Some(k) = map_.next_key()? {
364 match k {
365 GeneratedField::TableId => {
366 if table_id__.is_some() {
367 return Err(serde::de::Error::duplicate_field("tableId"));
368 }
369 table_id__ =
370 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
371 ;
372 }
373 GeneratedField::TableVersionId => {
374 if table_version_id__.is_some() {
375 return Err(serde::de::Error::duplicate_field("tableVersionId"));
376 }
377 table_version_id__ =
378 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
379 ;
380 }
381 GeneratedField::Returning => {
382 if returning__.is_some() {
383 return Err(serde::de::Error::duplicate_field("returning"));
384 }
385 returning__ = Some(map_.next_value()?);
386 }
387 GeneratedField::SessionId => {
388 if session_id__.is_some() {
389 return Err(serde::de::Error::duplicate_field("sessionId"));
390 }
391 session_id__ =
392 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
393 ;
394 }
395 }
396 }
397 Ok(DeleteNode {
398 table_id: table_id__.unwrap_or_default(),
399 table_version_id: table_version_id__.unwrap_or_default(),
400 returning: returning__.unwrap_or_default(),
401 session_id: session_id__.unwrap_or_default(),
402 })
403 }
404 }
405 deserializer.deserialize_struct("batch_plan.DeleteNode", FIELDS, GeneratedVisitor)
406 }
407}
408impl serde::Serialize for DistributedLookupJoinNode {
409 #[allow(deprecated)]
410 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
411 where
412 S: serde::Serializer,
413 {
414 use serde::ser::SerializeStruct;
415 let mut len = 0;
416 if self.join_type != 0 {
417 len += 1;
418 }
419 if self.condition.is_some() {
420 len += 1;
421 }
422 if !self.outer_side_key.is_empty() {
423 len += 1;
424 }
425 if !self.inner_side_key.is_empty() {
426 len += 1;
427 }
428 if self.lookup_prefix_len != 0 {
429 len += 1;
430 }
431 if self.inner_side_table_desc.is_some() {
432 len += 1;
433 }
434 if !self.inner_side_column_ids.is_empty() {
435 len += 1;
436 }
437 if !self.output_indices.is_empty() {
438 len += 1;
439 }
440 if !self.null_safe.is_empty() {
441 len += 1;
442 }
443 if self.as_of.is_some() {
444 len += 1;
445 }
446 if self.asof_desc.is_some() {
447 len += 1;
448 }
449 let mut struct_ser = serializer.serialize_struct("batch_plan.DistributedLookupJoinNode", len)?;
450 if self.join_type != 0 {
451 let v = super::plan_common::JoinType::try_from(self.join_type)
452 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
453 struct_ser.serialize_field("joinType", &v)?;
454 }
455 if let Some(v) = self.condition.as_ref() {
456 struct_ser.serialize_field("condition", v)?;
457 }
458 if !self.outer_side_key.is_empty() {
459 struct_ser.serialize_field("outerSideKey", &self.outer_side_key)?;
460 }
461 if !self.inner_side_key.is_empty() {
462 struct_ser.serialize_field("innerSideKey", &self.inner_side_key)?;
463 }
464 if self.lookup_prefix_len != 0 {
465 struct_ser.serialize_field("lookupPrefixLen", &self.lookup_prefix_len)?;
466 }
467 if let Some(v) = self.inner_side_table_desc.as_ref() {
468 struct_ser.serialize_field("innerSideTableDesc", v)?;
469 }
470 if !self.inner_side_column_ids.is_empty() {
471 struct_ser.serialize_field("innerSideColumnIds", &self.inner_side_column_ids)?;
472 }
473 if !self.output_indices.is_empty() {
474 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
475 }
476 if !self.null_safe.is_empty() {
477 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
478 }
479 if let Some(v) = self.as_of.as_ref() {
480 struct_ser.serialize_field("asOf", v)?;
481 }
482 if let Some(v) = self.asof_desc.as_ref() {
483 struct_ser.serialize_field("asofDesc", v)?;
484 }
485 struct_ser.end()
486 }
487}
488impl<'de> serde::Deserialize<'de> for DistributedLookupJoinNode {
489 #[allow(deprecated)]
490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
491 where
492 D: serde::Deserializer<'de>,
493 {
494 const FIELDS: &[&str] = &[
495 "join_type",
496 "joinType",
497 "condition",
498 "outer_side_key",
499 "outerSideKey",
500 "inner_side_key",
501 "innerSideKey",
502 "lookup_prefix_len",
503 "lookupPrefixLen",
504 "inner_side_table_desc",
505 "innerSideTableDesc",
506 "inner_side_column_ids",
507 "innerSideColumnIds",
508 "output_indices",
509 "outputIndices",
510 "null_safe",
511 "nullSafe",
512 "as_of",
513 "asOf",
514 "asof_desc",
515 "asofDesc",
516 ];
517
518 #[allow(clippy::enum_variant_names)]
519 enum GeneratedField {
520 JoinType,
521 Condition,
522 OuterSideKey,
523 InnerSideKey,
524 LookupPrefixLen,
525 InnerSideTableDesc,
526 InnerSideColumnIds,
527 OutputIndices,
528 NullSafe,
529 AsOf,
530 AsofDesc,
531 }
532 impl<'de> serde::Deserialize<'de> for GeneratedField {
533 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
534 where
535 D: serde::Deserializer<'de>,
536 {
537 struct GeneratedVisitor;
538
539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
540 type Value = GeneratedField;
541
542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
543 write!(formatter, "expected one of: {:?}", &FIELDS)
544 }
545
546 #[allow(unused_variables)]
547 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
548 where
549 E: serde::de::Error,
550 {
551 match value {
552 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
553 "condition" => Ok(GeneratedField::Condition),
554 "outerSideKey" | "outer_side_key" => Ok(GeneratedField::OuterSideKey),
555 "innerSideKey" | "inner_side_key" => Ok(GeneratedField::InnerSideKey),
556 "lookupPrefixLen" | "lookup_prefix_len" => Ok(GeneratedField::LookupPrefixLen),
557 "innerSideTableDesc" | "inner_side_table_desc" => Ok(GeneratedField::InnerSideTableDesc),
558 "innerSideColumnIds" | "inner_side_column_ids" => Ok(GeneratedField::InnerSideColumnIds),
559 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
560 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
561 "asOf" | "as_of" => Ok(GeneratedField::AsOf),
562 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
563 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
564 }
565 }
566 }
567 deserializer.deserialize_identifier(GeneratedVisitor)
568 }
569 }
570 struct GeneratedVisitor;
571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
572 type Value = DistributedLookupJoinNode;
573
574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
575 formatter.write_str("struct batch_plan.DistributedLookupJoinNode")
576 }
577
578 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DistributedLookupJoinNode, V::Error>
579 where
580 V: serde::de::MapAccess<'de>,
581 {
582 let mut join_type__ = None;
583 let mut condition__ = None;
584 let mut outer_side_key__ = None;
585 let mut inner_side_key__ = None;
586 let mut lookup_prefix_len__ = None;
587 let mut inner_side_table_desc__ = None;
588 let mut inner_side_column_ids__ = None;
589 let mut output_indices__ = None;
590 let mut null_safe__ = None;
591 let mut as_of__ = None;
592 let mut asof_desc__ = None;
593 while let Some(k) = map_.next_key()? {
594 match k {
595 GeneratedField::JoinType => {
596 if join_type__.is_some() {
597 return Err(serde::de::Error::duplicate_field("joinType"));
598 }
599 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
600 }
601 GeneratedField::Condition => {
602 if condition__.is_some() {
603 return Err(serde::de::Error::duplicate_field("condition"));
604 }
605 condition__ = map_.next_value()?;
606 }
607 GeneratedField::OuterSideKey => {
608 if outer_side_key__.is_some() {
609 return Err(serde::de::Error::duplicate_field("outerSideKey"));
610 }
611 outer_side_key__ =
612 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
613 .into_iter().map(|x| x.0).collect())
614 ;
615 }
616 GeneratedField::InnerSideKey => {
617 if inner_side_key__.is_some() {
618 return Err(serde::de::Error::duplicate_field("innerSideKey"));
619 }
620 inner_side_key__ =
621 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
622 .into_iter().map(|x| x.0).collect())
623 ;
624 }
625 GeneratedField::LookupPrefixLen => {
626 if lookup_prefix_len__.is_some() {
627 return Err(serde::de::Error::duplicate_field("lookupPrefixLen"));
628 }
629 lookup_prefix_len__ =
630 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
631 ;
632 }
633 GeneratedField::InnerSideTableDesc => {
634 if inner_side_table_desc__.is_some() {
635 return Err(serde::de::Error::duplicate_field("innerSideTableDesc"));
636 }
637 inner_side_table_desc__ = map_.next_value()?;
638 }
639 GeneratedField::InnerSideColumnIds => {
640 if inner_side_column_ids__.is_some() {
641 return Err(serde::de::Error::duplicate_field("innerSideColumnIds"));
642 }
643 inner_side_column_ids__ =
644 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
645 .into_iter().map(|x| x.0).collect())
646 ;
647 }
648 GeneratedField::OutputIndices => {
649 if output_indices__.is_some() {
650 return Err(serde::de::Error::duplicate_field("outputIndices"));
651 }
652 output_indices__ =
653 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
654 .into_iter().map(|x| x.0).collect())
655 ;
656 }
657 GeneratedField::NullSafe => {
658 if null_safe__.is_some() {
659 return Err(serde::de::Error::duplicate_field("nullSafe"));
660 }
661 null_safe__ = Some(map_.next_value()?);
662 }
663 GeneratedField::AsOf => {
664 if as_of__.is_some() {
665 return Err(serde::de::Error::duplicate_field("asOf"));
666 }
667 as_of__ = map_.next_value()?;
668 }
669 GeneratedField::AsofDesc => {
670 if asof_desc__.is_some() {
671 return Err(serde::de::Error::duplicate_field("asofDesc"));
672 }
673 asof_desc__ = map_.next_value()?;
674 }
675 }
676 }
677 Ok(DistributedLookupJoinNode {
678 join_type: join_type__.unwrap_or_default(),
679 condition: condition__,
680 outer_side_key: outer_side_key__.unwrap_or_default(),
681 inner_side_key: inner_side_key__.unwrap_or_default(),
682 lookup_prefix_len: lookup_prefix_len__.unwrap_or_default(),
683 inner_side_table_desc: inner_side_table_desc__,
684 inner_side_column_ids: inner_side_column_ids__.unwrap_or_default(),
685 output_indices: output_indices__.unwrap_or_default(),
686 null_safe: null_safe__.unwrap_or_default(),
687 as_of: as_of__,
688 asof_desc: asof_desc__,
689 })
690 }
691 }
692 deserializer.deserialize_struct("batch_plan.DistributedLookupJoinNode", FIELDS, GeneratedVisitor)
693 }
694}
695impl serde::Serialize for ExchangeInfo {
696 #[allow(deprecated)]
697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
698 where
699 S: serde::Serializer,
700 {
701 use serde::ser::SerializeStruct;
702 let mut len = 0;
703 if self.mode != 0 {
704 len += 1;
705 }
706 if self.distribution.is_some() {
707 len += 1;
708 }
709 let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeInfo", len)?;
710 if self.mode != 0 {
711 let v = exchange_info::DistributionMode::try_from(self.mode)
712 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?;
713 struct_ser.serialize_field("mode", &v)?;
714 }
715 if let Some(v) = self.distribution.as_ref() {
716 match v {
717 exchange_info::Distribution::BroadcastInfo(v) => {
718 struct_ser.serialize_field("broadcastInfo", v)?;
719 }
720 exchange_info::Distribution::HashInfo(v) => {
721 struct_ser.serialize_field("hashInfo", v)?;
722 }
723 exchange_info::Distribution::ConsistentHashInfo(v) => {
724 struct_ser.serialize_field("consistentHashInfo", v)?;
725 }
726 }
727 }
728 struct_ser.end()
729 }
730}
731impl<'de> serde::Deserialize<'de> for ExchangeInfo {
732 #[allow(deprecated)]
733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
734 where
735 D: serde::Deserializer<'de>,
736 {
737 const FIELDS: &[&str] = &[
738 "mode",
739 "broadcast_info",
740 "broadcastInfo",
741 "hash_info",
742 "hashInfo",
743 "consistent_hash_info",
744 "consistentHashInfo",
745 ];
746
747 #[allow(clippy::enum_variant_names)]
748 enum GeneratedField {
749 Mode,
750 BroadcastInfo,
751 HashInfo,
752 ConsistentHashInfo,
753 }
754 impl<'de> serde::Deserialize<'de> for GeneratedField {
755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
756 where
757 D: serde::Deserializer<'de>,
758 {
759 struct GeneratedVisitor;
760
761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
762 type Value = GeneratedField;
763
764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
765 write!(formatter, "expected one of: {:?}", &FIELDS)
766 }
767
768 #[allow(unused_variables)]
769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
770 where
771 E: serde::de::Error,
772 {
773 match value {
774 "mode" => Ok(GeneratedField::Mode),
775 "broadcastInfo" | "broadcast_info" => Ok(GeneratedField::BroadcastInfo),
776 "hashInfo" | "hash_info" => Ok(GeneratedField::HashInfo),
777 "consistentHashInfo" | "consistent_hash_info" => Ok(GeneratedField::ConsistentHashInfo),
778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
779 }
780 }
781 }
782 deserializer.deserialize_identifier(GeneratedVisitor)
783 }
784 }
785 struct GeneratedVisitor;
786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
787 type Value = ExchangeInfo;
788
789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
790 formatter.write_str("struct batch_plan.ExchangeInfo")
791 }
792
793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeInfo, V::Error>
794 where
795 V: serde::de::MapAccess<'de>,
796 {
797 let mut mode__ = None;
798 let mut distribution__ = None;
799 while let Some(k) = map_.next_key()? {
800 match k {
801 GeneratedField::Mode => {
802 if mode__.is_some() {
803 return Err(serde::de::Error::duplicate_field("mode"));
804 }
805 mode__ = Some(map_.next_value::<exchange_info::DistributionMode>()? as i32);
806 }
807 GeneratedField::BroadcastInfo => {
808 if distribution__.is_some() {
809 return Err(serde::de::Error::duplicate_field("broadcastInfo"));
810 }
811 distribution__ = map_.next_value::<::std::option::Option<_>>()?.map(exchange_info::Distribution::BroadcastInfo)
812;
813 }
814 GeneratedField::HashInfo => {
815 if distribution__.is_some() {
816 return Err(serde::de::Error::duplicate_field("hashInfo"));
817 }
818 distribution__ = map_.next_value::<::std::option::Option<_>>()?.map(exchange_info::Distribution::HashInfo)
819;
820 }
821 GeneratedField::ConsistentHashInfo => {
822 if distribution__.is_some() {
823 return Err(serde::de::Error::duplicate_field("consistentHashInfo"));
824 }
825 distribution__ = map_.next_value::<::std::option::Option<_>>()?.map(exchange_info::Distribution::ConsistentHashInfo)
826;
827 }
828 }
829 }
830 Ok(ExchangeInfo {
831 mode: mode__.unwrap_or_default(),
832 distribution: distribution__,
833 })
834 }
835 }
836 deserializer.deserialize_struct("batch_plan.ExchangeInfo", FIELDS, GeneratedVisitor)
837 }
838}
839impl serde::Serialize for exchange_info::BroadcastInfo {
840 #[allow(deprecated)]
841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
842 where
843 S: serde::Serializer,
844 {
845 use serde::ser::SerializeStruct;
846 let mut len = 0;
847 if self.count != 0 {
848 len += 1;
849 }
850 let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeInfo.BroadcastInfo", len)?;
851 if self.count != 0 {
852 struct_ser.serialize_field("count", &self.count)?;
853 }
854 struct_ser.end()
855 }
856}
857impl<'de> serde::Deserialize<'de> for exchange_info::BroadcastInfo {
858 #[allow(deprecated)]
859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
860 where
861 D: serde::Deserializer<'de>,
862 {
863 const FIELDS: &[&str] = &[
864 "count",
865 ];
866
867 #[allow(clippy::enum_variant_names)]
868 enum GeneratedField {
869 Count,
870 }
871 impl<'de> serde::Deserialize<'de> for GeneratedField {
872 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
873 where
874 D: serde::Deserializer<'de>,
875 {
876 struct GeneratedVisitor;
877
878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
879 type Value = GeneratedField;
880
881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
882 write!(formatter, "expected one of: {:?}", &FIELDS)
883 }
884
885 #[allow(unused_variables)]
886 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
887 where
888 E: serde::de::Error,
889 {
890 match value {
891 "count" => Ok(GeneratedField::Count),
892 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
893 }
894 }
895 }
896 deserializer.deserialize_identifier(GeneratedVisitor)
897 }
898 }
899 struct GeneratedVisitor;
900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
901 type Value = exchange_info::BroadcastInfo;
902
903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
904 formatter.write_str("struct batch_plan.ExchangeInfo.BroadcastInfo")
905 }
906
907 fn visit_map<V>(self, mut map_: V) -> std::result::Result<exchange_info::BroadcastInfo, V::Error>
908 where
909 V: serde::de::MapAccess<'de>,
910 {
911 let mut count__ = None;
912 while let Some(k) = map_.next_key()? {
913 match k {
914 GeneratedField::Count => {
915 if count__.is_some() {
916 return Err(serde::de::Error::duplicate_field("count"));
917 }
918 count__ =
919 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
920 ;
921 }
922 }
923 }
924 Ok(exchange_info::BroadcastInfo {
925 count: count__.unwrap_or_default(),
926 })
927 }
928 }
929 deserializer.deserialize_struct("batch_plan.ExchangeInfo.BroadcastInfo", FIELDS, GeneratedVisitor)
930 }
931}
932impl serde::Serialize for exchange_info::ConsistentHashInfo {
933 #[allow(deprecated)]
934 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
935 where
936 S: serde::Serializer,
937 {
938 use serde::ser::SerializeStruct;
939 let mut len = 0;
940 if !self.vmap.is_empty() {
941 len += 1;
942 }
943 if !self.key.is_empty() {
944 len += 1;
945 }
946 let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeInfo.ConsistentHashInfo", len)?;
947 if !self.vmap.is_empty() {
948 struct_ser.serialize_field("vmap", &self.vmap)?;
949 }
950 if !self.key.is_empty() {
951 struct_ser.serialize_field("key", &self.key)?;
952 }
953 struct_ser.end()
954 }
955}
956impl<'de> serde::Deserialize<'de> for exchange_info::ConsistentHashInfo {
957 #[allow(deprecated)]
958 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
959 where
960 D: serde::Deserializer<'de>,
961 {
962 const FIELDS: &[&str] = &[
963 "vmap",
964 "key",
965 ];
966
967 #[allow(clippy::enum_variant_names)]
968 enum GeneratedField {
969 Vmap,
970 Key,
971 }
972 impl<'de> serde::Deserialize<'de> for GeneratedField {
973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
974 where
975 D: serde::Deserializer<'de>,
976 {
977 struct GeneratedVisitor;
978
979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
980 type Value = GeneratedField;
981
982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
983 write!(formatter, "expected one of: {:?}", &FIELDS)
984 }
985
986 #[allow(unused_variables)]
987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
988 where
989 E: serde::de::Error,
990 {
991 match value {
992 "vmap" => Ok(GeneratedField::Vmap),
993 "key" => Ok(GeneratedField::Key),
994 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
995 }
996 }
997 }
998 deserializer.deserialize_identifier(GeneratedVisitor)
999 }
1000 }
1001 struct GeneratedVisitor;
1002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1003 type Value = exchange_info::ConsistentHashInfo;
1004
1005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1006 formatter.write_str("struct batch_plan.ExchangeInfo.ConsistentHashInfo")
1007 }
1008
1009 fn visit_map<V>(self, mut map_: V) -> std::result::Result<exchange_info::ConsistentHashInfo, V::Error>
1010 where
1011 V: serde::de::MapAccess<'de>,
1012 {
1013 let mut vmap__ = None;
1014 let mut key__ = None;
1015 while let Some(k) = map_.next_key()? {
1016 match k {
1017 GeneratedField::Vmap => {
1018 if vmap__.is_some() {
1019 return Err(serde::de::Error::duplicate_field("vmap"));
1020 }
1021 vmap__ =
1022 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1023 .into_iter().map(|x| x.0).collect())
1024 ;
1025 }
1026 GeneratedField::Key => {
1027 if key__.is_some() {
1028 return Err(serde::de::Error::duplicate_field("key"));
1029 }
1030 key__ =
1031 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1032 .into_iter().map(|x| x.0).collect())
1033 ;
1034 }
1035 }
1036 }
1037 Ok(exchange_info::ConsistentHashInfo {
1038 vmap: vmap__.unwrap_or_default(),
1039 key: key__.unwrap_or_default(),
1040 })
1041 }
1042 }
1043 deserializer.deserialize_struct("batch_plan.ExchangeInfo.ConsistentHashInfo", FIELDS, GeneratedVisitor)
1044 }
1045}
1046impl serde::Serialize for exchange_info::DistributionMode {
1047 #[allow(deprecated)]
1048 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1049 where
1050 S: serde::Serializer,
1051 {
1052 let variant = match self {
1053 Self::Unspecified => "UNSPECIFIED",
1054 Self::Single => "SINGLE",
1055 Self::Broadcast => "BROADCAST",
1056 Self::Hash => "HASH",
1057 Self::ConsistentHash => "CONSISTENT_HASH",
1058 };
1059 serializer.serialize_str(variant)
1060 }
1061}
1062impl<'de> serde::Deserialize<'de> for exchange_info::DistributionMode {
1063 #[allow(deprecated)]
1064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1065 where
1066 D: serde::Deserializer<'de>,
1067 {
1068 const FIELDS: &[&str] = &[
1069 "UNSPECIFIED",
1070 "SINGLE",
1071 "BROADCAST",
1072 "HASH",
1073 "CONSISTENT_HASH",
1074 ];
1075
1076 struct GeneratedVisitor;
1077
1078 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1079 type Value = exchange_info::DistributionMode;
1080
1081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1082 write!(formatter, "expected one of: {:?}", &FIELDS)
1083 }
1084
1085 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1086 where
1087 E: serde::de::Error,
1088 {
1089 i32::try_from(v)
1090 .ok()
1091 .and_then(|x| x.try_into().ok())
1092 .ok_or_else(|| {
1093 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1094 })
1095 }
1096
1097 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1098 where
1099 E: serde::de::Error,
1100 {
1101 i32::try_from(v)
1102 .ok()
1103 .and_then(|x| x.try_into().ok())
1104 .ok_or_else(|| {
1105 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1106 })
1107 }
1108
1109 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1110 where
1111 E: serde::de::Error,
1112 {
1113 match value {
1114 "UNSPECIFIED" => Ok(exchange_info::DistributionMode::Unspecified),
1115 "SINGLE" => Ok(exchange_info::DistributionMode::Single),
1116 "BROADCAST" => Ok(exchange_info::DistributionMode::Broadcast),
1117 "HASH" => Ok(exchange_info::DistributionMode::Hash),
1118 "CONSISTENT_HASH" => Ok(exchange_info::DistributionMode::ConsistentHash),
1119 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1120 }
1121 }
1122 }
1123 deserializer.deserialize_any(GeneratedVisitor)
1124 }
1125}
1126impl serde::Serialize for exchange_info::HashInfo {
1127 #[allow(deprecated)]
1128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1129 where
1130 S: serde::Serializer,
1131 {
1132 use serde::ser::SerializeStruct;
1133 let mut len = 0;
1134 if self.output_count != 0 {
1135 len += 1;
1136 }
1137 if !self.key.is_empty() {
1138 len += 1;
1139 }
1140 let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeInfo.HashInfo", len)?;
1141 if self.output_count != 0 {
1142 struct_ser.serialize_field("outputCount", &self.output_count)?;
1143 }
1144 if !self.key.is_empty() {
1145 struct_ser.serialize_field("key", &self.key)?;
1146 }
1147 struct_ser.end()
1148 }
1149}
1150impl<'de> serde::Deserialize<'de> for exchange_info::HashInfo {
1151 #[allow(deprecated)]
1152 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1153 where
1154 D: serde::Deserializer<'de>,
1155 {
1156 const FIELDS: &[&str] = &[
1157 "output_count",
1158 "outputCount",
1159 "key",
1160 ];
1161
1162 #[allow(clippy::enum_variant_names)]
1163 enum GeneratedField {
1164 OutputCount,
1165 Key,
1166 }
1167 impl<'de> serde::Deserialize<'de> for GeneratedField {
1168 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1169 where
1170 D: serde::Deserializer<'de>,
1171 {
1172 struct GeneratedVisitor;
1173
1174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1175 type Value = GeneratedField;
1176
1177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1178 write!(formatter, "expected one of: {:?}", &FIELDS)
1179 }
1180
1181 #[allow(unused_variables)]
1182 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1183 where
1184 E: serde::de::Error,
1185 {
1186 match value {
1187 "outputCount" | "output_count" => Ok(GeneratedField::OutputCount),
1188 "key" => Ok(GeneratedField::Key),
1189 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1190 }
1191 }
1192 }
1193 deserializer.deserialize_identifier(GeneratedVisitor)
1194 }
1195 }
1196 struct GeneratedVisitor;
1197 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1198 type Value = exchange_info::HashInfo;
1199
1200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1201 formatter.write_str("struct batch_plan.ExchangeInfo.HashInfo")
1202 }
1203
1204 fn visit_map<V>(self, mut map_: V) -> std::result::Result<exchange_info::HashInfo, V::Error>
1205 where
1206 V: serde::de::MapAccess<'de>,
1207 {
1208 let mut output_count__ = None;
1209 let mut key__ = None;
1210 while let Some(k) = map_.next_key()? {
1211 match k {
1212 GeneratedField::OutputCount => {
1213 if output_count__.is_some() {
1214 return Err(serde::de::Error::duplicate_field("outputCount"));
1215 }
1216 output_count__ =
1217 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1218 ;
1219 }
1220 GeneratedField::Key => {
1221 if key__.is_some() {
1222 return Err(serde::de::Error::duplicate_field("key"));
1223 }
1224 key__ =
1225 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1226 .into_iter().map(|x| x.0).collect())
1227 ;
1228 }
1229 }
1230 }
1231 Ok(exchange_info::HashInfo {
1232 output_count: output_count__.unwrap_or_default(),
1233 key: key__.unwrap_or_default(),
1234 })
1235 }
1236 }
1237 deserializer.deserialize_struct("batch_plan.ExchangeInfo.HashInfo", FIELDS, GeneratedVisitor)
1238 }
1239}
1240impl serde::Serialize for ExchangeNode {
1241 #[allow(deprecated)]
1242 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1243 where
1244 S: serde::Serializer,
1245 {
1246 use serde::ser::SerializeStruct;
1247 let mut len = 0;
1248 if !self.sources.is_empty() {
1249 len += 1;
1250 }
1251 if self.sequential {
1252 len += 1;
1253 }
1254 if !self.input_schema.is_empty() {
1255 len += 1;
1256 }
1257 let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeNode", len)?;
1258 if !self.sources.is_empty() {
1259 struct_ser.serialize_field("sources", &self.sources)?;
1260 }
1261 if self.sequential {
1262 struct_ser.serialize_field("sequential", &self.sequential)?;
1263 }
1264 if !self.input_schema.is_empty() {
1265 struct_ser.serialize_field("inputSchema", &self.input_schema)?;
1266 }
1267 struct_ser.end()
1268 }
1269}
1270impl<'de> serde::Deserialize<'de> for ExchangeNode {
1271 #[allow(deprecated)]
1272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1273 where
1274 D: serde::Deserializer<'de>,
1275 {
1276 const FIELDS: &[&str] = &[
1277 "sources",
1278 "sequential",
1279 "input_schema",
1280 "inputSchema",
1281 ];
1282
1283 #[allow(clippy::enum_variant_names)]
1284 enum GeneratedField {
1285 Sources,
1286 Sequential,
1287 InputSchema,
1288 }
1289 impl<'de> serde::Deserialize<'de> for GeneratedField {
1290 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1291 where
1292 D: serde::Deserializer<'de>,
1293 {
1294 struct GeneratedVisitor;
1295
1296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1297 type Value = GeneratedField;
1298
1299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1300 write!(formatter, "expected one of: {:?}", &FIELDS)
1301 }
1302
1303 #[allow(unused_variables)]
1304 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1305 where
1306 E: serde::de::Error,
1307 {
1308 match value {
1309 "sources" => Ok(GeneratedField::Sources),
1310 "sequential" => Ok(GeneratedField::Sequential),
1311 "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema),
1312 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1313 }
1314 }
1315 }
1316 deserializer.deserialize_identifier(GeneratedVisitor)
1317 }
1318 }
1319 struct GeneratedVisitor;
1320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1321 type Value = ExchangeNode;
1322
1323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1324 formatter.write_str("struct batch_plan.ExchangeNode")
1325 }
1326
1327 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
1328 where
1329 V: serde::de::MapAccess<'de>,
1330 {
1331 let mut sources__ = None;
1332 let mut sequential__ = None;
1333 let mut input_schema__ = None;
1334 while let Some(k) = map_.next_key()? {
1335 match k {
1336 GeneratedField::Sources => {
1337 if sources__.is_some() {
1338 return Err(serde::de::Error::duplicate_field("sources"));
1339 }
1340 sources__ = Some(map_.next_value()?);
1341 }
1342 GeneratedField::Sequential => {
1343 if sequential__.is_some() {
1344 return Err(serde::de::Error::duplicate_field("sequential"));
1345 }
1346 sequential__ = Some(map_.next_value()?);
1347 }
1348 GeneratedField::InputSchema => {
1349 if input_schema__.is_some() {
1350 return Err(serde::de::Error::duplicate_field("inputSchema"));
1351 }
1352 input_schema__ = Some(map_.next_value()?);
1353 }
1354 }
1355 }
1356 Ok(ExchangeNode {
1357 sources: sources__.unwrap_or_default(),
1358 sequential: sequential__.unwrap_or_default(),
1359 input_schema: input_schema__.unwrap_or_default(),
1360 })
1361 }
1362 }
1363 deserializer.deserialize_struct("batch_plan.ExchangeNode", FIELDS, GeneratedVisitor)
1364 }
1365}
1366impl serde::Serialize for ExchangeSource {
1367 #[allow(deprecated)]
1368 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1369 where
1370 S: serde::Serializer,
1371 {
1372 use serde::ser::SerializeStruct;
1373 let mut len = 0;
1374 if self.task_output_id.is_some() {
1375 len += 1;
1376 }
1377 if self.host.is_some() {
1378 len += 1;
1379 }
1380 if self.local_execute_plan.is_some() {
1381 len += 1;
1382 }
1383 let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeSource", len)?;
1384 if let Some(v) = self.task_output_id.as_ref() {
1385 struct_ser.serialize_field("taskOutputId", v)?;
1386 }
1387 if let Some(v) = self.host.as_ref() {
1388 struct_ser.serialize_field("host", v)?;
1389 }
1390 if let Some(v) = self.local_execute_plan.as_ref() {
1391 match v {
1392 exchange_source::LocalExecutePlan::Plan(v) => {
1393 struct_ser.serialize_field("plan", v)?;
1394 }
1395 }
1396 }
1397 struct_ser.end()
1398 }
1399}
1400impl<'de> serde::Deserialize<'de> for ExchangeSource {
1401 #[allow(deprecated)]
1402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1403 where
1404 D: serde::Deserializer<'de>,
1405 {
1406 const FIELDS: &[&str] = &[
1407 "task_output_id",
1408 "taskOutputId",
1409 "host",
1410 "plan",
1411 ];
1412
1413 #[allow(clippy::enum_variant_names)]
1414 enum GeneratedField {
1415 TaskOutputId,
1416 Host,
1417 Plan,
1418 }
1419 impl<'de> serde::Deserialize<'de> for GeneratedField {
1420 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1421 where
1422 D: serde::Deserializer<'de>,
1423 {
1424 struct GeneratedVisitor;
1425
1426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1427 type Value = GeneratedField;
1428
1429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1430 write!(formatter, "expected one of: {:?}", &FIELDS)
1431 }
1432
1433 #[allow(unused_variables)]
1434 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1435 where
1436 E: serde::de::Error,
1437 {
1438 match value {
1439 "taskOutputId" | "task_output_id" => Ok(GeneratedField::TaskOutputId),
1440 "host" => Ok(GeneratedField::Host),
1441 "plan" => Ok(GeneratedField::Plan),
1442 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1443 }
1444 }
1445 }
1446 deserializer.deserialize_identifier(GeneratedVisitor)
1447 }
1448 }
1449 struct GeneratedVisitor;
1450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1451 type Value = ExchangeSource;
1452
1453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1454 formatter.write_str("struct batch_plan.ExchangeSource")
1455 }
1456
1457 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeSource, V::Error>
1458 where
1459 V: serde::de::MapAccess<'de>,
1460 {
1461 let mut task_output_id__ = None;
1462 let mut host__ = None;
1463 let mut local_execute_plan__ = None;
1464 while let Some(k) = map_.next_key()? {
1465 match k {
1466 GeneratedField::TaskOutputId => {
1467 if task_output_id__.is_some() {
1468 return Err(serde::de::Error::duplicate_field("taskOutputId"));
1469 }
1470 task_output_id__ = map_.next_value()?;
1471 }
1472 GeneratedField::Host => {
1473 if host__.is_some() {
1474 return Err(serde::de::Error::duplicate_field("host"));
1475 }
1476 host__ = map_.next_value()?;
1477 }
1478 GeneratedField::Plan => {
1479 if local_execute_plan__.is_some() {
1480 return Err(serde::de::Error::duplicate_field("plan"));
1481 }
1482 local_execute_plan__ = map_.next_value::<::std::option::Option<_>>()?.map(exchange_source::LocalExecutePlan::Plan)
1483;
1484 }
1485 }
1486 }
1487 Ok(ExchangeSource {
1488 task_output_id: task_output_id__,
1489 host: host__,
1490 local_execute_plan: local_execute_plan__,
1491 })
1492 }
1493 }
1494 deserializer.deserialize_struct("batch_plan.ExchangeSource", FIELDS, GeneratedVisitor)
1495 }
1496}
1497impl serde::Serialize for ExpandNode {
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.column_subsets.is_empty() {
1506 len += 1;
1507 }
1508 let mut struct_ser = serializer.serialize_struct("batch_plan.ExpandNode", len)?;
1509 if !self.column_subsets.is_empty() {
1510 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
1511 }
1512 struct_ser.end()
1513 }
1514}
1515impl<'de> serde::Deserialize<'de> for ExpandNode {
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 "column_subsets",
1523 "columnSubsets",
1524 ];
1525
1526 #[allow(clippy::enum_variant_names)]
1527 enum GeneratedField {
1528 ColumnSubsets,
1529 }
1530 impl<'de> serde::Deserialize<'de> for GeneratedField {
1531 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1532 where
1533 D: serde::Deserializer<'de>,
1534 {
1535 struct GeneratedVisitor;
1536
1537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1538 type Value = GeneratedField;
1539
1540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1541 write!(formatter, "expected one of: {:?}", &FIELDS)
1542 }
1543
1544 #[allow(unused_variables)]
1545 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1546 where
1547 E: serde::de::Error,
1548 {
1549 match value {
1550 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
1551 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1552 }
1553 }
1554 }
1555 deserializer.deserialize_identifier(GeneratedVisitor)
1556 }
1557 }
1558 struct GeneratedVisitor;
1559 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1560 type Value = ExpandNode;
1561
1562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1563 formatter.write_str("struct batch_plan.ExpandNode")
1564 }
1565
1566 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
1567 where
1568 V: serde::de::MapAccess<'de>,
1569 {
1570 let mut column_subsets__ = None;
1571 while let Some(k) = map_.next_key()? {
1572 match k {
1573 GeneratedField::ColumnSubsets => {
1574 if column_subsets__.is_some() {
1575 return Err(serde::de::Error::duplicate_field("columnSubsets"));
1576 }
1577 column_subsets__ = Some(map_.next_value()?);
1578 }
1579 }
1580 }
1581 Ok(ExpandNode {
1582 column_subsets: column_subsets__.unwrap_or_default(),
1583 })
1584 }
1585 }
1586 deserializer.deserialize_struct("batch_plan.ExpandNode", FIELDS, GeneratedVisitor)
1587 }
1588}
1589impl serde::Serialize for expand_node::Subset {
1590 #[allow(deprecated)]
1591 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1592 where
1593 S: serde::Serializer,
1594 {
1595 use serde::ser::SerializeStruct;
1596 let mut len = 0;
1597 if !self.column_indices.is_empty() {
1598 len += 1;
1599 }
1600 let mut struct_ser = serializer.serialize_struct("batch_plan.ExpandNode.Subset", len)?;
1601 if !self.column_indices.is_empty() {
1602 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
1603 }
1604 struct_ser.end()
1605 }
1606}
1607impl<'de> serde::Deserialize<'de> for expand_node::Subset {
1608 #[allow(deprecated)]
1609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1610 where
1611 D: serde::Deserializer<'de>,
1612 {
1613 const FIELDS: &[&str] = &[
1614 "column_indices",
1615 "columnIndices",
1616 ];
1617
1618 #[allow(clippy::enum_variant_names)]
1619 enum GeneratedField {
1620 ColumnIndices,
1621 }
1622 impl<'de> serde::Deserialize<'de> for GeneratedField {
1623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1624 where
1625 D: serde::Deserializer<'de>,
1626 {
1627 struct GeneratedVisitor;
1628
1629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1630 type Value = GeneratedField;
1631
1632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1633 write!(formatter, "expected one of: {:?}", &FIELDS)
1634 }
1635
1636 #[allow(unused_variables)]
1637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1638 where
1639 E: serde::de::Error,
1640 {
1641 match value {
1642 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
1643 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1644 }
1645 }
1646 }
1647 deserializer.deserialize_identifier(GeneratedVisitor)
1648 }
1649 }
1650 struct GeneratedVisitor;
1651 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1652 type Value = expand_node::Subset;
1653
1654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1655 formatter.write_str("struct batch_plan.ExpandNode.Subset")
1656 }
1657
1658 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
1659 where
1660 V: serde::de::MapAccess<'de>,
1661 {
1662 let mut column_indices__ = None;
1663 while let Some(k) = map_.next_key()? {
1664 match k {
1665 GeneratedField::ColumnIndices => {
1666 if column_indices__.is_some() {
1667 return Err(serde::de::Error::duplicate_field("columnIndices"));
1668 }
1669 column_indices__ =
1670 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1671 .into_iter().map(|x| x.0).collect())
1672 ;
1673 }
1674 }
1675 }
1676 Ok(expand_node::Subset {
1677 column_indices: column_indices__.unwrap_or_default(),
1678 })
1679 }
1680 }
1681 deserializer.deserialize_struct("batch_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
1682 }
1683}
1684impl serde::Serialize for FileScanNode {
1685 #[allow(deprecated)]
1686 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1687 where
1688 S: serde::Serializer,
1689 {
1690 use serde::ser::SerializeStruct;
1691 let mut len = 0;
1692 if !self.columns.is_empty() {
1693 len += 1;
1694 }
1695 if self.file_format != 0 {
1696 len += 1;
1697 }
1698 if self.storage_type != 0 {
1699 len += 1;
1700 }
1701 if !self.s3_region.is_empty() {
1702 len += 1;
1703 }
1704 if !self.s3_access_key.is_empty() {
1705 len += 1;
1706 }
1707 if !self.s3_secret_key.is_empty() {
1708 len += 1;
1709 }
1710 if !self.file_location.is_empty() {
1711 len += 1;
1712 }
1713 if !self.s3_endpoint.is_empty() {
1714 len += 1;
1715 }
1716 let mut struct_ser = serializer.serialize_struct("batch_plan.FileScanNode", len)?;
1717 if !self.columns.is_empty() {
1718 struct_ser.serialize_field("columns", &self.columns)?;
1719 }
1720 if self.file_format != 0 {
1721 let v = file_scan_node::FileFormat::try_from(self.file_format)
1722 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.file_format)))?;
1723 struct_ser.serialize_field("fileFormat", &v)?;
1724 }
1725 if self.storage_type != 0 {
1726 let v = file_scan_node::StorageType::try_from(self.storage_type)
1727 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.storage_type)))?;
1728 struct_ser.serialize_field("storageType", &v)?;
1729 }
1730 if !self.s3_region.is_empty() {
1731 struct_ser.serialize_field("s3Region", &self.s3_region)?;
1732 }
1733 if !self.s3_access_key.is_empty() {
1734 struct_ser.serialize_field("s3AccessKey", &self.s3_access_key)?;
1735 }
1736 if !self.s3_secret_key.is_empty() {
1737 struct_ser.serialize_field("s3SecretKey", &self.s3_secret_key)?;
1738 }
1739 if !self.file_location.is_empty() {
1740 struct_ser.serialize_field("fileLocation", &self.file_location)?;
1741 }
1742 if !self.s3_endpoint.is_empty() {
1743 struct_ser.serialize_field("s3Endpoint", &self.s3_endpoint)?;
1744 }
1745 struct_ser.end()
1746 }
1747}
1748impl<'de> serde::Deserialize<'de> for FileScanNode {
1749 #[allow(deprecated)]
1750 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1751 where
1752 D: serde::Deserializer<'de>,
1753 {
1754 const FIELDS: &[&str] = &[
1755 "columns",
1756 "file_format",
1757 "fileFormat",
1758 "storage_type",
1759 "storageType",
1760 "s3_region",
1761 "s3Region",
1762 "s3_access_key",
1763 "s3AccessKey",
1764 "s3_secret_key",
1765 "s3SecretKey",
1766 "file_location",
1767 "fileLocation",
1768 "s3_endpoint",
1769 "s3Endpoint",
1770 ];
1771
1772 #[allow(clippy::enum_variant_names)]
1773 enum GeneratedField {
1774 Columns,
1775 FileFormat,
1776 StorageType,
1777 S3Region,
1778 S3AccessKey,
1779 S3SecretKey,
1780 FileLocation,
1781 S3Endpoint,
1782 }
1783 impl<'de> serde::Deserialize<'de> for GeneratedField {
1784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1785 where
1786 D: serde::Deserializer<'de>,
1787 {
1788 struct GeneratedVisitor;
1789
1790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1791 type Value = GeneratedField;
1792
1793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1794 write!(formatter, "expected one of: {:?}", &FIELDS)
1795 }
1796
1797 #[allow(unused_variables)]
1798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1799 where
1800 E: serde::de::Error,
1801 {
1802 match value {
1803 "columns" => Ok(GeneratedField::Columns),
1804 "fileFormat" | "file_format" => Ok(GeneratedField::FileFormat),
1805 "storageType" | "storage_type" => Ok(GeneratedField::StorageType),
1806 "s3Region" | "s3_region" => Ok(GeneratedField::S3Region),
1807 "s3AccessKey" | "s3_access_key" => Ok(GeneratedField::S3AccessKey),
1808 "s3SecretKey" | "s3_secret_key" => Ok(GeneratedField::S3SecretKey),
1809 "fileLocation" | "file_location" => Ok(GeneratedField::FileLocation),
1810 "s3Endpoint" | "s3_endpoint" => Ok(GeneratedField::S3Endpoint),
1811 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1812 }
1813 }
1814 }
1815 deserializer.deserialize_identifier(GeneratedVisitor)
1816 }
1817 }
1818 struct GeneratedVisitor;
1819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1820 type Value = FileScanNode;
1821
1822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1823 formatter.write_str("struct batch_plan.FileScanNode")
1824 }
1825
1826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FileScanNode, V::Error>
1827 where
1828 V: serde::de::MapAccess<'de>,
1829 {
1830 let mut columns__ = None;
1831 let mut file_format__ = None;
1832 let mut storage_type__ = None;
1833 let mut s3_region__ = None;
1834 let mut s3_access_key__ = None;
1835 let mut s3_secret_key__ = None;
1836 let mut file_location__ = None;
1837 let mut s3_endpoint__ = None;
1838 while let Some(k) = map_.next_key()? {
1839 match k {
1840 GeneratedField::Columns => {
1841 if columns__.is_some() {
1842 return Err(serde::de::Error::duplicate_field("columns"));
1843 }
1844 columns__ = Some(map_.next_value()?);
1845 }
1846 GeneratedField::FileFormat => {
1847 if file_format__.is_some() {
1848 return Err(serde::de::Error::duplicate_field("fileFormat"));
1849 }
1850 file_format__ = Some(map_.next_value::<file_scan_node::FileFormat>()? as i32);
1851 }
1852 GeneratedField::StorageType => {
1853 if storage_type__.is_some() {
1854 return Err(serde::de::Error::duplicate_field("storageType"));
1855 }
1856 storage_type__ = Some(map_.next_value::<file_scan_node::StorageType>()? as i32);
1857 }
1858 GeneratedField::S3Region => {
1859 if s3_region__.is_some() {
1860 return Err(serde::de::Error::duplicate_field("s3Region"));
1861 }
1862 s3_region__ = Some(map_.next_value()?);
1863 }
1864 GeneratedField::S3AccessKey => {
1865 if s3_access_key__.is_some() {
1866 return Err(serde::de::Error::duplicate_field("s3AccessKey"));
1867 }
1868 s3_access_key__ = Some(map_.next_value()?);
1869 }
1870 GeneratedField::S3SecretKey => {
1871 if s3_secret_key__.is_some() {
1872 return Err(serde::de::Error::duplicate_field("s3SecretKey"));
1873 }
1874 s3_secret_key__ = Some(map_.next_value()?);
1875 }
1876 GeneratedField::FileLocation => {
1877 if file_location__.is_some() {
1878 return Err(serde::de::Error::duplicate_field("fileLocation"));
1879 }
1880 file_location__ = Some(map_.next_value()?);
1881 }
1882 GeneratedField::S3Endpoint => {
1883 if s3_endpoint__.is_some() {
1884 return Err(serde::de::Error::duplicate_field("s3Endpoint"));
1885 }
1886 s3_endpoint__ = Some(map_.next_value()?);
1887 }
1888 }
1889 }
1890 Ok(FileScanNode {
1891 columns: columns__.unwrap_or_default(),
1892 file_format: file_format__.unwrap_or_default(),
1893 storage_type: storage_type__.unwrap_or_default(),
1894 s3_region: s3_region__.unwrap_or_default(),
1895 s3_access_key: s3_access_key__.unwrap_or_default(),
1896 s3_secret_key: s3_secret_key__.unwrap_or_default(),
1897 file_location: file_location__.unwrap_or_default(),
1898 s3_endpoint: s3_endpoint__.unwrap_or_default(),
1899 })
1900 }
1901 }
1902 deserializer.deserialize_struct("batch_plan.FileScanNode", FIELDS, GeneratedVisitor)
1903 }
1904}
1905impl serde::Serialize for file_scan_node::FileFormat {
1906 #[allow(deprecated)]
1907 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1908 where
1909 S: serde::Serializer,
1910 {
1911 let variant = match self {
1912 Self::Unspecified => "FILE_FORMAT_UNSPECIFIED",
1913 Self::Parquet => "PARQUET",
1914 };
1915 serializer.serialize_str(variant)
1916 }
1917}
1918impl<'de> serde::Deserialize<'de> for file_scan_node::FileFormat {
1919 #[allow(deprecated)]
1920 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1921 where
1922 D: serde::Deserializer<'de>,
1923 {
1924 const FIELDS: &[&str] = &[
1925 "FILE_FORMAT_UNSPECIFIED",
1926 "PARQUET",
1927 ];
1928
1929 struct GeneratedVisitor;
1930
1931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1932 type Value = file_scan_node::FileFormat;
1933
1934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1935 write!(formatter, "expected one of: {:?}", &FIELDS)
1936 }
1937
1938 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1939 where
1940 E: serde::de::Error,
1941 {
1942 i32::try_from(v)
1943 .ok()
1944 .and_then(|x| x.try_into().ok())
1945 .ok_or_else(|| {
1946 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1947 })
1948 }
1949
1950 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1951 where
1952 E: serde::de::Error,
1953 {
1954 i32::try_from(v)
1955 .ok()
1956 .and_then(|x| x.try_into().ok())
1957 .ok_or_else(|| {
1958 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1959 })
1960 }
1961
1962 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1963 where
1964 E: serde::de::Error,
1965 {
1966 match value {
1967 "FILE_FORMAT_UNSPECIFIED" => Ok(file_scan_node::FileFormat::Unspecified),
1968 "PARQUET" => Ok(file_scan_node::FileFormat::Parquet),
1969 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1970 }
1971 }
1972 }
1973 deserializer.deserialize_any(GeneratedVisitor)
1974 }
1975}
1976impl serde::Serialize for file_scan_node::StorageType {
1977 #[allow(deprecated)]
1978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1979 where
1980 S: serde::Serializer,
1981 {
1982 let variant = match self {
1983 Self::Unspecified => "STORAGE_TYPE_UNSPECIFIED",
1984 Self::S3 => "S3",
1985 Self::Gcs => "GCS",
1986 Self::Azblob => "AZBLOB",
1987 };
1988 serializer.serialize_str(variant)
1989 }
1990}
1991impl<'de> serde::Deserialize<'de> for file_scan_node::StorageType {
1992 #[allow(deprecated)]
1993 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1994 where
1995 D: serde::Deserializer<'de>,
1996 {
1997 const FIELDS: &[&str] = &[
1998 "STORAGE_TYPE_UNSPECIFIED",
1999 "S3",
2000 "GCS",
2001 "AZBLOB",
2002 ];
2003
2004 struct GeneratedVisitor;
2005
2006 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2007 type Value = file_scan_node::StorageType;
2008
2009 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2010 write!(formatter, "expected one of: {:?}", &FIELDS)
2011 }
2012
2013 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2014 where
2015 E: serde::de::Error,
2016 {
2017 i32::try_from(v)
2018 .ok()
2019 .and_then(|x| x.try_into().ok())
2020 .ok_or_else(|| {
2021 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2022 })
2023 }
2024
2025 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2026 where
2027 E: serde::de::Error,
2028 {
2029 i32::try_from(v)
2030 .ok()
2031 .and_then(|x| x.try_into().ok())
2032 .ok_or_else(|| {
2033 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2034 })
2035 }
2036
2037 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2038 where
2039 E: serde::de::Error,
2040 {
2041 match value {
2042 "STORAGE_TYPE_UNSPECIFIED" => Ok(file_scan_node::StorageType::Unspecified),
2043 "S3" => Ok(file_scan_node::StorageType::S3),
2044 "GCS" => Ok(file_scan_node::StorageType::Gcs),
2045 "AZBLOB" => Ok(file_scan_node::StorageType::Azblob),
2046 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2047 }
2048 }
2049 }
2050 deserializer.deserialize_any(GeneratedVisitor)
2051 }
2052}
2053impl serde::Serialize for FilterNode {
2054 #[allow(deprecated)]
2055 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2056 where
2057 S: serde::Serializer,
2058 {
2059 use serde::ser::SerializeStruct;
2060 let mut len = 0;
2061 if self.search_condition.is_some() {
2062 len += 1;
2063 }
2064 let mut struct_ser = serializer.serialize_struct("batch_plan.FilterNode", len)?;
2065 if let Some(v) = self.search_condition.as_ref() {
2066 struct_ser.serialize_field("searchCondition", v)?;
2067 }
2068 struct_ser.end()
2069 }
2070}
2071impl<'de> serde::Deserialize<'de> for FilterNode {
2072 #[allow(deprecated)]
2073 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2074 where
2075 D: serde::Deserializer<'de>,
2076 {
2077 const FIELDS: &[&str] = &[
2078 "search_condition",
2079 "searchCondition",
2080 ];
2081
2082 #[allow(clippy::enum_variant_names)]
2083 enum GeneratedField {
2084 SearchCondition,
2085 }
2086 impl<'de> serde::Deserialize<'de> for GeneratedField {
2087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2088 where
2089 D: serde::Deserializer<'de>,
2090 {
2091 struct GeneratedVisitor;
2092
2093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2094 type Value = GeneratedField;
2095
2096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2097 write!(formatter, "expected one of: {:?}", &FIELDS)
2098 }
2099
2100 #[allow(unused_variables)]
2101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2102 where
2103 E: serde::de::Error,
2104 {
2105 match value {
2106 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2107 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2108 }
2109 }
2110 }
2111 deserializer.deserialize_identifier(GeneratedVisitor)
2112 }
2113 }
2114 struct GeneratedVisitor;
2115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2116 type Value = FilterNode;
2117
2118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2119 formatter.write_str("struct batch_plan.FilterNode")
2120 }
2121
2122 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
2123 where
2124 V: serde::de::MapAccess<'de>,
2125 {
2126 let mut search_condition__ = None;
2127 while let Some(k) = map_.next_key()? {
2128 match k {
2129 GeneratedField::SearchCondition => {
2130 if search_condition__.is_some() {
2131 return Err(serde::de::Error::duplicate_field("searchCondition"));
2132 }
2133 search_condition__ = map_.next_value()?;
2134 }
2135 }
2136 }
2137 Ok(FilterNode {
2138 search_condition: search_condition__,
2139 })
2140 }
2141 }
2142 deserializer.deserialize_struct("batch_plan.FilterNode", FIELDS, GeneratedVisitor)
2143 }
2144}
2145impl serde::Serialize for GcsFileScanNode {
2146 #[allow(deprecated)]
2147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2148 where
2149 S: serde::Serializer,
2150 {
2151 use serde::ser::SerializeStruct;
2152 let mut len = 0;
2153 if !self.columns.is_empty() {
2154 len += 1;
2155 }
2156 if self.file_format != 0 {
2157 len += 1;
2158 }
2159 if !self.credential.is_empty() {
2160 len += 1;
2161 }
2162 if !self.file_location.is_empty() {
2163 len += 1;
2164 }
2165 let mut struct_ser = serializer.serialize_struct("batch_plan.GcsFileScanNode", len)?;
2166 if !self.columns.is_empty() {
2167 struct_ser.serialize_field("columns", &self.columns)?;
2168 }
2169 if self.file_format != 0 {
2170 let v = gcs_file_scan_node::FileFormat::try_from(self.file_format)
2171 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.file_format)))?;
2172 struct_ser.serialize_field("fileFormat", &v)?;
2173 }
2174 if !self.credential.is_empty() {
2175 struct_ser.serialize_field("credential", &self.credential)?;
2176 }
2177 if !self.file_location.is_empty() {
2178 struct_ser.serialize_field("fileLocation", &self.file_location)?;
2179 }
2180 struct_ser.end()
2181 }
2182}
2183impl<'de> serde::Deserialize<'de> for GcsFileScanNode {
2184 #[allow(deprecated)]
2185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2186 where
2187 D: serde::Deserializer<'de>,
2188 {
2189 const FIELDS: &[&str] = &[
2190 "columns",
2191 "file_format",
2192 "fileFormat",
2193 "credential",
2194 "file_location",
2195 "fileLocation",
2196 ];
2197
2198 #[allow(clippy::enum_variant_names)]
2199 enum GeneratedField {
2200 Columns,
2201 FileFormat,
2202 Credential,
2203 FileLocation,
2204 }
2205 impl<'de> serde::Deserialize<'de> for GeneratedField {
2206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2207 where
2208 D: serde::Deserializer<'de>,
2209 {
2210 struct GeneratedVisitor;
2211
2212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2213 type Value = GeneratedField;
2214
2215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2216 write!(formatter, "expected one of: {:?}", &FIELDS)
2217 }
2218
2219 #[allow(unused_variables)]
2220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2221 where
2222 E: serde::de::Error,
2223 {
2224 match value {
2225 "columns" => Ok(GeneratedField::Columns),
2226 "fileFormat" | "file_format" => Ok(GeneratedField::FileFormat),
2227 "credential" => Ok(GeneratedField::Credential),
2228 "fileLocation" | "file_location" => Ok(GeneratedField::FileLocation),
2229 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2230 }
2231 }
2232 }
2233 deserializer.deserialize_identifier(GeneratedVisitor)
2234 }
2235 }
2236 struct GeneratedVisitor;
2237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2238 type Value = GcsFileScanNode;
2239
2240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2241 formatter.write_str("struct batch_plan.GcsFileScanNode")
2242 }
2243
2244 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GcsFileScanNode, V::Error>
2245 where
2246 V: serde::de::MapAccess<'de>,
2247 {
2248 let mut columns__ = None;
2249 let mut file_format__ = None;
2250 let mut credential__ = None;
2251 let mut file_location__ = None;
2252 while let Some(k) = map_.next_key()? {
2253 match k {
2254 GeneratedField::Columns => {
2255 if columns__.is_some() {
2256 return Err(serde::de::Error::duplicate_field("columns"));
2257 }
2258 columns__ = Some(map_.next_value()?);
2259 }
2260 GeneratedField::FileFormat => {
2261 if file_format__.is_some() {
2262 return Err(serde::de::Error::duplicate_field("fileFormat"));
2263 }
2264 file_format__ = Some(map_.next_value::<gcs_file_scan_node::FileFormat>()? as i32);
2265 }
2266 GeneratedField::Credential => {
2267 if credential__.is_some() {
2268 return Err(serde::de::Error::duplicate_field("credential"));
2269 }
2270 credential__ = Some(map_.next_value()?);
2271 }
2272 GeneratedField::FileLocation => {
2273 if file_location__.is_some() {
2274 return Err(serde::de::Error::duplicate_field("fileLocation"));
2275 }
2276 file_location__ = Some(map_.next_value()?);
2277 }
2278 }
2279 }
2280 Ok(GcsFileScanNode {
2281 columns: columns__.unwrap_or_default(),
2282 file_format: file_format__.unwrap_or_default(),
2283 credential: credential__.unwrap_or_default(),
2284 file_location: file_location__.unwrap_or_default(),
2285 })
2286 }
2287 }
2288 deserializer.deserialize_struct("batch_plan.GcsFileScanNode", FIELDS, GeneratedVisitor)
2289 }
2290}
2291impl serde::Serialize for gcs_file_scan_node::FileFormat {
2292 #[allow(deprecated)]
2293 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2294 where
2295 S: serde::Serializer,
2296 {
2297 let variant = match self {
2298 Self::Unspecified => "FILE_FORMAT_UNSPECIFIED",
2299 Self::Parquet => "PARQUET",
2300 };
2301 serializer.serialize_str(variant)
2302 }
2303}
2304impl<'de> serde::Deserialize<'de> for gcs_file_scan_node::FileFormat {
2305 #[allow(deprecated)]
2306 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2307 where
2308 D: serde::Deserializer<'de>,
2309 {
2310 const FIELDS: &[&str] = &[
2311 "FILE_FORMAT_UNSPECIFIED",
2312 "PARQUET",
2313 ];
2314
2315 struct GeneratedVisitor;
2316
2317 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2318 type Value = gcs_file_scan_node::FileFormat;
2319
2320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2321 write!(formatter, "expected one of: {:?}", &FIELDS)
2322 }
2323
2324 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2325 where
2326 E: serde::de::Error,
2327 {
2328 i32::try_from(v)
2329 .ok()
2330 .and_then(|x| x.try_into().ok())
2331 .ok_or_else(|| {
2332 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2333 })
2334 }
2335
2336 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2337 where
2338 E: serde::de::Error,
2339 {
2340 i32::try_from(v)
2341 .ok()
2342 .and_then(|x| x.try_into().ok())
2343 .ok_or_else(|| {
2344 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2345 })
2346 }
2347
2348 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2349 where
2350 E: serde::de::Error,
2351 {
2352 match value {
2353 "FILE_FORMAT_UNSPECIFIED" => Ok(gcs_file_scan_node::FileFormat::Unspecified),
2354 "PARQUET" => Ok(gcs_file_scan_node::FileFormat::Parquet),
2355 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2356 }
2357 }
2358 }
2359 deserializer.deserialize_any(GeneratedVisitor)
2360 }
2361}
2362impl serde::Serialize for GroupTopNNode {
2363 #[allow(deprecated)]
2364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2365 where
2366 S: serde::Serializer,
2367 {
2368 use serde::ser::SerializeStruct;
2369 let mut len = 0;
2370 if !self.column_orders.is_empty() {
2371 len += 1;
2372 }
2373 if self.limit != 0 {
2374 len += 1;
2375 }
2376 if self.offset != 0 {
2377 len += 1;
2378 }
2379 if !self.group_key.is_empty() {
2380 len += 1;
2381 }
2382 if self.with_ties {
2383 len += 1;
2384 }
2385 let mut struct_ser = serializer.serialize_struct("batch_plan.GroupTopNNode", len)?;
2386 if !self.column_orders.is_empty() {
2387 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
2388 }
2389 if self.limit != 0 {
2390 #[allow(clippy::needless_borrow)]
2391 #[allow(clippy::needless_borrows_for_generic_args)]
2392 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
2393 }
2394 if self.offset != 0 {
2395 #[allow(clippy::needless_borrow)]
2396 #[allow(clippy::needless_borrows_for_generic_args)]
2397 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
2398 }
2399 if !self.group_key.is_empty() {
2400 struct_ser.serialize_field("groupKey", &self.group_key)?;
2401 }
2402 if self.with_ties {
2403 struct_ser.serialize_field("withTies", &self.with_ties)?;
2404 }
2405 struct_ser.end()
2406 }
2407}
2408impl<'de> serde::Deserialize<'de> for GroupTopNNode {
2409 #[allow(deprecated)]
2410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2411 where
2412 D: serde::Deserializer<'de>,
2413 {
2414 const FIELDS: &[&str] = &[
2415 "column_orders",
2416 "columnOrders",
2417 "limit",
2418 "offset",
2419 "group_key",
2420 "groupKey",
2421 "with_ties",
2422 "withTies",
2423 ];
2424
2425 #[allow(clippy::enum_variant_names)]
2426 enum GeneratedField {
2427 ColumnOrders,
2428 Limit,
2429 Offset,
2430 GroupKey,
2431 WithTies,
2432 }
2433 impl<'de> serde::Deserialize<'de> for GeneratedField {
2434 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2435 where
2436 D: serde::Deserializer<'de>,
2437 {
2438 struct GeneratedVisitor;
2439
2440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2441 type Value = GeneratedField;
2442
2443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2444 write!(formatter, "expected one of: {:?}", &FIELDS)
2445 }
2446
2447 #[allow(unused_variables)]
2448 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2449 where
2450 E: serde::de::Error,
2451 {
2452 match value {
2453 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
2454 "limit" => Ok(GeneratedField::Limit),
2455 "offset" => Ok(GeneratedField::Offset),
2456 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
2457 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
2458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2459 }
2460 }
2461 }
2462 deserializer.deserialize_identifier(GeneratedVisitor)
2463 }
2464 }
2465 struct GeneratedVisitor;
2466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2467 type Value = GroupTopNNode;
2468
2469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2470 formatter.write_str("struct batch_plan.GroupTopNNode")
2471 }
2472
2473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
2474 where
2475 V: serde::de::MapAccess<'de>,
2476 {
2477 let mut column_orders__ = None;
2478 let mut limit__ = None;
2479 let mut offset__ = None;
2480 let mut group_key__ = None;
2481 let mut with_ties__ = None;
2482 while let Some(k) = map_.next_key()? {
2483 match k {
2484 GeneratedField::ColumnOrders => {
2485 if column_orders__.is_some() {
2486 return Err(serde::de::Error::duplicate_field("columnOrders"));
2487 }
2488 column_orders__ = Some(map_.next_value()?);
2489 }
2490 GeneratedField::Limit => {
2491 if limit__.is_some() {
2492 return Err(serde::de::Error::duplicate_field("limit"));
2493 }
2494 limit__ =
2495 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2496 ;
2497 }
2498 GeneratedField::Offset => {
2499 if offset__.is_some() {
2500 return Err(serde::de::Error::duplicate_field("offset"));
2501 }
2502 offset__ =
2503 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2504 ;
2505 }
2506 GeneratedField::GroupKey => {
2507 if group_key__.is_some() {
2508 return Err(serde::de::Error::duplicate_field("groupKey"));
2509 }
2510 group_key__ =
2511 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2512 .into_iter().map(|x| x.0).collect())
2513 ;
2514 }
2515 GeneratedField::WithTies => {
2516 if with_ties__.is_some() {
2517 return Err(serde::de::Error::duplicate_field("withTies"));
2518 }
2519 with_ties__ = Some(map_.next_value()?);
2520 }
2521 }
2522 }
2523 Ok(GroupTopNNode {
2524 column_orders: column_orders__.unwrap_or_default(),
2525 limit: limit__.unwrap_or_default(),
2526 offset: offset__.unwrap_or_default(),
2527 group_key: group_key__.unwrap_or_default(),
2528 with_ties: with_ties__.unwrap_or_default(),
2529 })
2530 }
2531 }
2532 deserializer.deserialize_struct("batch_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
2533 }
2534}
2535impl serde::Serialize for HashAggNode {
2536 #[allow(deprecated)]
2537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2538 where
2539 S: serde::Serializer,
2540 {
2541 use serde::ser::SerializeStruct;
2542 let mut len = 0;
2543 if !self.group_key.is_empty() {
2544 len += 1;
2545 }
2546 if !self.agg_calls.is_empty() {
2547 len += 1;
2548 }
2549 let mut struct_ser = serializer.serialize_struct("batch_plan.HashAggNode", len)?;
2550 if !self.group_key.is_empty() {
2551 struct_ser.serialize_field("groupKey", &self.group_key)?;
2552 }
2553 if !self.agg_calls.is_empty() {
2554 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
2555 }
2556 struct_ser.end()
2557 }
2558}
2559impl<'de> serde::Deserialize<'de> for HashAggNode {
2560 #[allow(deprecated)]
2561 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2562 where
2563 D: serde::Deserializer<'de>,
2564 {
2565 const FIELDS: &[&str] = &[
2566 "group_key",
2567 "groupKey",
2568 "agg_calls",
2569 "aggCalls",
2570 ];
2571
2572 #[allow(clippy::enum_variant_names)]
2573 enum GeneratedField {
2574 GroupKey,
2575 AggCalls,
2576 }
2577 impl<'de> serde::Deserialize<'de> for GeneratedField {
2578 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2579 where
2580 D: serde::Deserializer<'de>,
2581 {
2582 struct GeneratedVisitor;
2583
2584 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2585 type Value = GeneratedField;
2586
2587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2588 write!(formatter, "expected one of: {:?}", &FIELDS)
2589 }
2590
2591 #[allow(unused_variables)]
2592 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2593 where
2594 E: serde::de::Error,
2595 {
2596 match value {
2597 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
2598 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
2599 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2600 }
2601 }
2602 }
2603 deserializer.deserialize_identifier(GeneratedVisitor)
2604 }
2605 }
2606 struct GeneratedVisitor;
2607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2608 type Value = HashAggNode;
2609
2610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2611 formatter.write_str("struct batch_plan.HashAggNode")
2612 }
2613
2614 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
2615 where
2616 V: serde::de::MapAccess<'de>,
2617 {
2618 let mut group_key__ = None;
2619 let mut agg_calls__ = None;
2620 while let Some(k) = map_.next_key()? {
2621 match k {
2622 GeneratedField::GroupKey => {
2623 if group_key__.is_some() {
2624 return Err(serde::de::Error::duplicate_field("groupKey"));
2625 }
2626 group_key__ =
2627 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2628 .into_iter().map(|x| x.0).collect())
2629 ;
2630 }
2631 GeneratedField::AggCalls => {
2632 if agg_calls__.is_some() {
2633 return Err(serde::de::Error::duplicate_field("aggCalls"));
2634 }
2635 agg_calls__ = Some(map_.next_value()?);
2636 }
2637 }
2638 }
2639 Ok(HashAggNode {
2640 group_key: group_key__.unwrap_or_default(),
2641 agg_calls: agg_calls__.unwrap_or_default(),
2642 })
2643 }
2644 }
2645 deserializer.deserialize_struct("batch_plan.HashAggNode", FIELDS, GeneratedVisitor)
2646 }
2647}
2648impl serde::Serialize for HashJoinNode {
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.join_type != 0 {
2657 len += 1;
2658 }
2659 if !self.left_key.is_empty() {
2660 len += 1;
2661 }
2662 if !self.right_key.is_empty() {
2663 len += 1;
2664 }
2665 if self.condition.is_some() {
2666 len += 1;
2667 }
2668 if !self.output_indices.is_empty() {
2669 len += 1;
2670 }
2671 if !self.null_safe.is_empty() {
2672 len += 1;
2673 }
2674 if self.asof_desc.is_some() {
2675 len += 1;
2676 }
2677 let mut struct_ser = serializer.serialize_struct("batch_plan.HashJoinNode", len)?;
2678 if self.join_type != 0 {
2679 let v = super::plan_common::JoinType::try_from(self.join_type)
2680 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2681 struct_ser.serialize_field("joinType", &v)?;
2682 }
2683 if !self.left_key.is_empty() {
2684 struct_ser.serialize_field("leftKey", &self.left_key)?;
2685 }
2686 if !self.right_key.is_empty() {
2687 struct_ser.serialize_field("rightKey", &self.right_key)?;
2688 }
2689 if let Some(v) = self.condition.as_ref() {
2690 struct_ser.serialize_field("condition", v)?;
2691 }
2692 if !self.output_indices.is_empty() {
2693 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2694 }
2695 if !self.null_safe.is_empty() {
2696 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
2697 }
2698 if let Some(v) = self.asof_desc.as_ref() {
2699 struct_ser.serialize_field("asofDesc", v)?;
2700 }
2701 struct_ser.end()
2702 }
2703}
2704impl<'de> serde::Deserialize<'de> for HashJoinNode {
2705 #[allow(deprecated)]
2706 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2707 where
2708 D: serde::Deserializer<'de>,
2709 {
2710 const FIELDS: &[&str] = &[
2711 "join_type",
2712 "joinType",
2713 "left_key",
2714 "leftKey",
2715 "right_key",
2716 "rightKey",
2717 "condition",
2718 "output_indices",
2719 "outputIndices",
2720 "null_safe",
2721 "nullSafe",
2722 "asof_desc",
2723 "asofDesc",
2724 ];
2725
2726 #[allow(clippy::enum_variant_names)]
2727 enum GeneratedField {
2728 JoinType,
2729 LeftKey,
2730 RightKey,
2731 Condition,
2732 OutputIndices,
2733 NullSafe,
2734 AsofDesc,
2735 }
2736 impl<'de> serde::Deserialize<'de> for GeneratedField {
2737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2738 where
2739 D: serde::Deserializer<'de>,
2740 {
2741 struct GeneratedVisitor;
2742
2743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2744 type Value = GeneratedField;
2745
2746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2747 write!(formatter, "expected one of: {:?}", &FIELDS)
2748 }
2749
2750 #[allow(unused_variables)]
2751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2752 where
2753 E: serde::de::Error,
2754 {
2755 match value {
2756 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
2757 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
2758 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
2759 "condition" => Ok(GeneratedField::Condition),
2760 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2761 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
2762 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
2763 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2764 }
2765 }
2766 }
2767 deserializer.deserialize_identifier(GeneratedVisitor)
2768 }
2769 }
2770 struct GeneratedVisitor;
2771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2772 type Value = HashJoinNode;
2773
2774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2775 formatter.write_str("struct batch_plan.HashJoinNode")
2776 }
2777
2778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
2779 where
2780 V: serde::de::MapAccess<'de>,
2781 {
2782 let mut join_type__ = None;
2783 let mut left_key__ = None;
2784 let mut right_key__ = None;
2785 let mut condition__ = None;
2786 let mut output_indices__ = None;
2787 let mut null_safe__ = None;
2788 let mut asof_desc__ = None;
2789 while let Some(k) = map_.next_key()? {
2790 match k {
2791 GeneratedField::JoinType => {
2792 if join_type__.is_some() {
2793 return Err(serde::de::Error::duplicate_field("joinType"));
2794 }
2795 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
2796 }
2797 GeneratedField::LeftKey => {
2798 if left_key__.is_some() {
2799 return Err(serde::de::Error::duplicate_field("leftKey"));
2800 }
2801 left_key__ =
2802 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2803 .into_iter().map(|x| x.0).collect())
2804 ;
2805 }
2806 GeneratedField::RightKey => {
2807 if right_key__.is_some() {
2808 return Err(serde::de::Error::duplicate_field("rightKey"));
2809 }
2810 right_key__ =
2811 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2812 .into_iter().map(|x| x.0).collect())
2813 ;
2814 }
2815 GeneratedField::Condition => {
2816 if condition__.is_some() {
2817 return Err(serde::de::Error::duplicate_field("condition"));
2818 }
2819 condition__ = map_.next_value()?;
2820 }
2821 GeneratedField::OutputIndices => {
2822 if output_indices__.is_some() {
2823 return Err(serde::de::Error::duplicate_field("outputIndices"));
2824 }
2825 output_indices__ =
2826 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2827 .into_iter().map(|x| x.0).collect())
2828 ;
2829 }
2830 GeneratedField::NullSafe => {
2831 if null_safe__.is_some() {
2832 return Err(serde::de::Error::duplicate_field("nullSafe"));
2833 }
2834 null_safe__ = Some(map_.next_value()?);
2835 }
2836 GeneratedField::AsofDesc => {
2837 if asof_desc__.is_some() {
2838 return Err(serde::de::Error::duplicate_field("asofDesc"));
2839 }
2840 asof_desc__ = map_.next_value()?;
2841 }
2842 }
2843 }
2844 Ok(HashJoinNode {
2845 join_type: join_type__.unwrap_or_default(),
2846 left_key: left_key__.unwrap_or_default(),
2847 right_key: right_key__.unwrap_or_default(),
2848 condition: condition__,
2849 output_indices: output_indices__.unwrap_or_default(),
2850 null_safe: null_safe__.unwrap_or_default(),
2851 asof_desc: asof_desc__,
2852 })
2853 }
2854 }
2855 deserializer.deserialize_struct("batch_plan.HashJoinNode", FIELDS, GeneratedVisitor)
2856 }
2857}
2858impl serde::Serialize for HopWindowNode {
2859 #[allow(deprecated)]
2860 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2861 where
2862 S: serde::Serializer,
2863 {
2864 use serde::ser::SerializeStruct;
2865 let mut len = 0;
2866 if self.time_col != 0 {
2867 len += 1;
2868 }
2869 if self.window_slide.is_some() {
2870 len += 1;
2871 }
2872 if self.window_size.is_some() {
2873 len += 1;
2874 }
2875 if !self.output_indices.is_empty() {
2876 len += 1;
2877 }
2878 if !self.window_start_exprs.is_empty() {
2879 len += 1;
2880 }
2881 if !self.window_end_exprs.is_empty() {
2882 len += 1;
2883 }
2884 let mut struct_ser = serializer.serialize_struct("batch_plan.HopWindowNode", len)?;
2885 if self.time_col != 0 {
2886 struct_ser.serialize_field("timeCol", &self.time_col)?;
2887 }
2888 if let Some(v) = self.window_slide.as_ref() {
2889 struct_ser.serialize_field("windowSlide", v)?;
2890 }
2891 if let Some(v) = self.window_size.as_ref() {
2892 struct_ser.serialize_field("windowSize", v)?;
2893 }
2894 if !self.output_indices.is_empty() {
2895 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2896 }
2897 if !self.window_start_exprs.is_empty() {
2898 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
2899 }
2900 if !self.window_end_exprs.is_empty() {
2901 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
2902 }
2903 struct_ser.end()
2904 }
2905}
2906impl<'de> serde::Deserialize<'de> for HopWindowNode {
2907 #[allow(deprecated)]
2908 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2909 where
2910 D: serde::Deserializer<'de>,
2911 {
2912 const FIELDS: &[&str] = &[
2913 "time_col",
2914 "timeCol",
2915 "window_slide",
2916 "windowSlide",
2917 "window_size",
2918 "windowSize",
2919 "output_indices",
2920 "outputIndices",
2921 "window_start_exprs",
2922 "windowStartExprs",
2923 "window_end_exprs",
2924 "windowEndExprs",
2925 ];
2926
2927 #[allow(clippy::enum_variant_names)]
2928 enum GeneratedField {
2929 TimeCol,
2930 WindowSlide,
2931 WindowSize,
2932 OutputIndices,
2933 WindowStartExprs,
2934 WindowEndExprs,
2935 }
2936 impl<'de> serde::Deserialize<'de> for GeneratedField {
2937 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2938 where
2939 D: serde::Deserializer<'de>,
2940 {
2941 struct GeneratedVisitor;
2942
2943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2944 type Value = GeneratedField;
2945
2946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2947 write!(formatter, "expected one of: {:?}", &FIELDS)
2948 }
2949
2950 #[allow(unused_variables)]
2951 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2952 where
2953 E: serde::de::Error,
2954 {
2955 match value {
2956 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
2957 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
2958 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
2959 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2960 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
2961 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
2962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2963 }
2964 }
2965 }
2966 deserializer.deserialize_identifier(GeneratedVisitor)
2967 }
2968 }
2969 struct GeneratedVisitor;
2970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2971 type Value = HopWindowNode;
2972
2973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2974 formatter.write_str("struct batch_plan.HopWindowNode")
2975 }
2976
2977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
2978 where
2979 V: serde::de::MapAccess<'de>,
2980 {
2981 let mut time_col__ = None;
2982 let mut window_slide__ = None;
2983 let mut window_size__ = None;
2984 let mut output_indices__ = None;
2985 let mut window_start_exprs__ = None;
2986 let mut window_end_exprs__ = None;
2987 while let Some(k) = map_.next_key()? {
2988 match k {
2989 GeneratedField::TimeCol => {
2990 if time_col__.is_some() {
2991 return Err(serde::de::Error::duplicate_field("timeCol"));
2992 }
2993 time_col__ =
2994 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2995 ;
2996 }
2997 GeneratedField::WindowSlide => {
2998 if window_slide__.is_some() {
2999 return Err(serde::de::Error::duplicate_field("windowSlide"));
3000 }
3001 window_slide__ = map_.next_value()?;
3002 }
3003 GeneratedField::WindowSize => {
3004 if window_size__.is_some() {
3005 return Err(serde::de::Error::duplicate_field("windowSize"));
3006 }
3007 window_size__ = map_.next_value()?;
3008 }
3009 GeneratedField::OutputIndices => {
3010 if output_indices__.is_some() {
3011 return Err(serde::de::Error::duplicate_field("outputIndices"));
3012 }
3013 output_indices__ =
3014 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3015 .into_iter().map(|x| x.0).collect())
3016 ;
3017 }
3018 GeneratedField::WindowStartExprs => {
3019 if window_start_exprs__.is_some() {
3020 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
3021 }
3022 window_start_exprs__ = Some(map_.next_value()?);
3023 }
3024 GeneratedField::WindowEndExprs => {
3025 if window_end_exprs__.is_some() {
3026 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
3027 }
3028 window_end_exprs__ = Some(map_.next_value()?);
3029 }
3030 }
3031 }
3032 Ok(HopWindowNode {
3033 time_col: time_col__.unwrap_or_default(),
3034 window_slide: window_slide__,
3035 window_size: window_size__,
3036 output_indices: output_indices__.unwrap_or_default(),
3037 window_start_exprs: window_start_exprs__.unwrap_or_default(),
3038 window_end_exprs: window_end_exprs__.unwrap_or_default(),
3039 })
3040 }
3041 }
3042 deserializer.deserialize_struct("batch_plan.HopWindowNode", FIELDS, GeneratedVisitor)
3043 }
3044}
3045impl serde::Serialize for IcebergScanNode {
3046 #[allow(deprecated)]
3047 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3048 where
3049 S: serde::Serializer,
3050 {
3051 use serde::ser::SerializeStruct;
3052 let mut len = 0;
3053 if !self.columns.is_empty() {
3054 len += 1;
3055 }
3056 if !self.with_properties.is_empty() {
3057 len += 1;
3058 }
3059 if !self.split.is_empty() {
3060 len += 1;
3061 }
3062 if !self.secret_refs.is_empty() {
3063 len += 1;
3064 }
3065 if self.iceberg_scan_type != 0 {
3066 len += 1;
3067 }
3068 let mut struct_ser = serializer.serialize_struct("batch_plan.IcebergScanNode", len)?;
3069 if !self.columns.is_empty() {
3070 struct_ser.serialize_field("columns", &self.columns)?;
3071 }
3072 if !self.with_properties.is_empty() {
3073 struct_ser.serialize_field("withProperties", &self.with_properties)?;
3074 }
3075 if !self.split.is_empty() {
3076 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
3077 }
3078 if !self.secret_refs.is_empty() {
3079 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3080 }
3081 if self.iceberg_scan_type != 0 {
3082 let v = iceberg_scan_node::IcebergScanType::try_from(self.iceberg_scan_type)
3083 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.iceberg_scan_type)))?;
3084 struct_ser.serialize_field("icebergScanType", &v)?;
3085 }
3086 struct_ser.end()
3087 }
3088}
3089impl<'de> serde::Deserialize<'de> for IcebergScanNode {
3090 #[allow(deprecated)]
3091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3092 where
3093 D: serde::Deserializer<'de>,
3094 {
3095 const FIELDS: &[&str] = &[
3096 "columns",
3097 "with_properties",
3098 "withProperties",
3099 "split",
3100 "secret_refs",
3101 "secretRefs",
3102 "iceberg_scan_type",
3103 "icebergScanType",
3104 ];
3105
3106 #[allow(clippy::enum_variant_names)]
3107 enum GeneratedField {
3108 Columns,
3109 WithProperties,
3110 Split,
3111 SecretRefs,
3112 IcebergScanType,
3113 }
3114 impl<'de> serde::Deserialize<'de> for GeneratedField {
3115 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3116 where
3117 D: serde::Deserializer<'de>,
3118 {
3119 struct GeneratedVisitor;
3120
3121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3122 type Value = GeneratedField;
3123
3124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3125 write!(formatter, "expected one of: {:?}", &FIELDS)
3126 }
3127
3128 #[allow(unused_variables)]
3129 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3130 where
3131 E: serde::de::Error,
3132 {
3133 match value {
3134 "columns" => Ok(GeneratedField::Columns),
3135 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
3136 "split" => Ok(GeneratedField::Split),
3137 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3138 "icebergScanType" | "iceberg_scan_type" => Ok(GeneratedField::IcebergScanType),
3139 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3140 }
3141 }
3142 }
3143 deserializer.deserialize_identifier(GeneratedVisitor)
3144 }
3145 }
3146 struct GeneratedVisitor;
3147 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3148 type Value = IcebergScanNode;
3149
3150 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3151 formatter.write_str("struct batch_plan.IcebergScanNode")
3152 }
3153
3154 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergScanNode, V::Error>
3155 where
3156 V: serde::de::MapAccess<'de>,
3157 {
3158 let mut columns__ = None;
3159 let mut with_properties__ = None;
3160 let mut split__ = None;
3161 let mut secret_refs__ = None;
3162 let mut iceberg_scan_type__ = None;
3163 while let Some(k) = map_.next_key()? {
3164 match k {
3165 GeneratedField::Columns => {
3166 if columns__.is_some() {
3167 return Err(serde::de::Error::duplicate_field("columns"));
3168 }
3169 columns__ = Some(map_.next_value()?);
3170 }
3171 GeneratedField::WithProperties => {
3172 if with_properties__.is_some() {
3173 return Err(serde::de::Error::duplicate_field("withProperties"));
3174 }
3175 with_properties__ = Some(
3176 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3177 );
3178 }
3179 GeneratedField::Split => {
3180 if split__.is_some() {
3181 return Err(serde::de::Error::duplicate_field("split"));
3182 }
3183 split__ =
3184 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
3185 .into_iter().map(|x| x.0).collect())
3186 ;
3187 }
3188 GeneratedField::SecretRefs => {
3189 if secret_refs__.is_some() {
3190 return Err(serde::de::Error::duplicate_field("secretRefs"));
3191 }
3192 secret_refs__ = Some(
3193 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3194 );
3195 }
3196 GeneratedField::IcebergScanType => {
3197 if iceberg_scan_type__.is_some() {
3198 return Err(serde::de::Error::duplicate_field("icebergScanType"));
3199 }
3200 iceberg_scan_type__ = Some(map_.next_value::<iceberg_scan_node::IcebergScanType>()? as i32);
3201 }
3202 }
3203 }
3204 Ok(IcebergScanNode {
3205 columns: columns__.unwrap_or_default(),
3206 with_properties: with_properties__.unwrap_or_default(),
3207 split: split__.unwrap_or_default(),
3208 secret_refs: secret_refs__.unwrap_or_default(),
3209 iceberg_scan_type: iceberg_scan_type__.unwrap_or_default(),
3210 })
3211 }
3212 }
3213 deserializer.deserialize_struct("batch_plan.IcebergScanNode", FIELDS, GeneratedVisitor)
3214 }
3215}
3216impl serde::Serialize for iceberg_scan_node::IcebergScanType {
3217 #[allow(deprecated)]
3218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3219 where
3220 S: serde::Serializer,
3221 {
3222 let variant = match self {
3223 Self::Unspecified => "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3224 Self::DataScan => "ICEBERG_SCAN_TYPE_DATA_SCAN",
3225 Self::EqualityDeleteScan => "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3226 Self::PositionDeleteScan => "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3227 Self::CountStar => "ICEBERG_SCAN_TYPE_COUNT_STAR",
3228 };
3229 serializer.serialize_str(variant)
3230 }
3231}
3232impl<'de> serde::Deserialize<'de> for iceberg_scan_node::IcebergScanType {
3233 #[allow(deprecated)]
3234 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3235 where
3236 D: serde::Deserializer<'de>,
3237 {
3238 const FIELDS: &[&str] = &[
3239 "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3240 "ICEBERG_SCAN_TYPE_DATA_SCAN",
3241 "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3242 "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3243 "ICEBERG_SCAN_TYPE_COUNT_STAR",
3244 ];
3245
3246 struct GeneratedVisitor;
3247
3248 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3249 type Value = iceberg_scan_node::IcebergScanType;
3250
3251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3252 write!(formatter, "expected one of: {:?}", &FIELDS)
3253 }
3254
3255 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3256 where
3257 E: serde::de::Error,
3258 {
3259 i32::try_from(v)
3260 .ok()
3261 .and_then(|x| x.try_into().ok())
3262 .ok_or_else(|| {
3263 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3264 })
3265 }
3266
3267 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3268 where
3269 E: serde::de::Error,
3270 {
3271 i32::try_from(v)
3272 .ok()
3273 .and_then(|x| x.try_into().ok())
3274 .ok_or_else(|| {
3275 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3276 })
3277 }
3278
3279 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3280 where
3281 E: serde::de::Error,
3282 {
3283 match value {
3284 "ICEBERG_SCAN_TYPE_UNSPECIFIED" => Ok(iceberg_scan_node::IcebergScanType::Unspecified),
3285 "ICEBERG_SCAN_TYPE_DATA_SCAN" => Ok(iceberg_scan_node::IcebergScanType::DataScan),
3286 "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::EqualityDeleteScan),
3287 "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::PositionDeleteScan),
3288 "ICEBERG_SCAN_TYPE_COUNT_STAR" => Ok(iceberg_scan_node::IcebergScanType::CountStar),
3289 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3290 }
3291 }
3292 }
3293 deserializer.deserialize_any(GeneratedVisitor)
3294 }
3295}
3296impl serde::Serialize for InsertNode {
3297 #[allow(deprecated)]
3298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3299 where
3300 S: serde::Serializer,
3301 {
3302 use serde::ser::SerializeStruct;
3303 let mut len = 0;
3304 if self.table_id != 0 {
3305 len += 1;
3306 }
3307 if self.table_version_id != 0 {
3308 len += 1;
3309 }
3310 if !self.column_indices.is_empty() {
3311 len += 1;
3312 }
3313 if self.default_columns.is_some() {
3314 len += 1;
3315 }
3316 if self.row_id_index.is_some() {
3317 len += 1;
3318 }
3319 if self.returning {
3320 len += 1;
3321 }
3322 if self.session_id != 0 {
3323 len += 1;
3324 }
3325 let mut struct_ser = serializer.serialize_struct("batch_plan.InsertNode", len)?;
3326 if self.table_id != 0 {
3327 struct_ser.serialize_field("tableId", &self.table_id)?;
3328 }
3329 if self.table_version_id != 0 {
3330 #[allow(clippy::needless_borrow)]
3331 #[allow(clippy::needless_borrows_for_generic_args)]
3332 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3333 }
3334 if !self.column_indices.is_empty() {
3335 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
3336 }
3337 if let Some(v) = self.default_columns.as_ref() {
3338 struct_ser.serialize_field("defaultColumns", v)?;
3339 }
3340 if let Some(v) = self.row_id_index.as_ref() {
3341 struct_ser.serialize_field("rowIdIndex", v)?;
3342 }
3343 if self.returning {
3344 struct_ser.serialize_field("returning", &self.returning)?;
3345 }
3346 if self.session_id != 0 {
3347 struct_ser.serialize_field("sessionId", &self.session_id)?;
3348 }
3349 struct_ser.end()
3350 }
3351}
3352impl<'de> serde::Deserialize<'de> for InsertNode {
3353 #[allow(deprecated)]
3354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3355 where
3356 D: serde::Deserializer<'de>,
3357 {
3358 const FIELDS: &[&str] = &[
3359 "table_id",
3360 "tableId",
3361 "table_version_id",
3362 "tableVersionId",
3363 "column_indices",
3364 "columnIndices",
3365 "default_columns",
3366 "defaultColumns",
3367 "row_id_index",
3368 "rowIdIndex",
3369 "returning",
3370 "session_id",
3371 "sessionId",
3372 ];
3373
3374 #[allow(clippy::enum_variant_names)]
3375 enum GeneratedField {
3376 TableId,
3377 TableVersionId,
3378 ColumnIndices,
3379 DefaultColumns,
3380 RowIdIndex,
3381 Returning,
3382 SessionId,
3383 }
3384 impl<'de> serde::Deserialize<'de> for GeneratedField {
3385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3386 where
3387 D: serde::Deserializer<'de>,
3388 {
3389 struct GeneratedVisitor;
3390
3391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3392 type Value = GeneratedField;
3393
3394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3395 write!(formatter, "expected one of: {:?}", &FIELDS)
3396 }
3397
3398 #[allow(unused_variables)]
3399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3400 where
3401 E: serde::de::Error,
3402 {
3403 match value {
3404 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3405 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3406 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
3407 "defaultColumns" | "default_columns" => Ok(GeneratedField::DefaultColumns),
3408 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
3409 "returning" => Ok(GeneratedField::Returning),
3410 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
3411 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3412 }
3413 }
3414 }
3415 deserializer.deserialize_identifier(GeneratedVisitor)
3416 }
3417 }
3418 struct GeneratedVisitor;
3419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3420 type Value = InsertNode;
3421
3422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3423 formatter.write_str("struct batch_plan.InsertNode")
3424 }
3425
3426 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InsertNode, V::Error>
3427 where
3428 V: serde::de::MapAccess<'de>,
3429 {
3430 let mut table_id__ = None;
3431 let mut table_version_id__ = None;
3432 let mut column_indices__ = None;
3433 let mut default_columns__ = None;
3434 let mut row_id_index__ = None;
3435 let mut returning__ = None;
3436 let mut session_id__ = None;
3437 while let Some(k) = map_.next_key()? {
3438 match k {
3439 GeneratedField::TableId => {
3440 if table_id__.is_some() {
3441 return Err(serde::de::Error::duplicate_field("tableId"));
3442 }
3443 table_id__ =
3444 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3445 ;
3446 }
3447 GeneratedField::TableVersionId => {
3448 if table_version_id__.is_some() {
3449 return Err(serde::de::Error::duplicate_field("tableVersionId"));
3450 }
3451 table_version_id__ =
3452 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3453 ;
3454 }
3455 GeneratedField::ColumnIndices => {
3456 if column_indices__.is_some() {
3457 return Err(serde::de::Error::duplicate_field("columnIndices"));
3458 }
3459 column_indices__ =
3460 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3461 .into_iter().map(|x| x.0).collect())
3462 ;
3463 }
3464 GeneratedField::DefaultColumns => {
3465 if default_columns__.is_some() {
3466 return Err(serde::de::Error::duplicate_field("defaultColumns"));
3467 }
3468 default_columns__ = map_.next_value()?;
3469 }
3470 GeneratedField::RowIdIndex => {
3471 if row_id_index__.is_some() {
3472 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
3473 }
3474 row_id_index__ =
3475 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3476 ;
3477 }
3478 GeneratedField::Returning => {
3479 if returning__.is_some() {
3480 return Err(serde::de::Error::duplicate_field("returning"));
3481 }
3482 returning__ = Some(map_.next_value()?);
3483 }
3484 GeneratedField::SessionId => {
3485 if session_id__.is_some() {
3486 return Err(serde::de::Error::duplicate_field("sessionId"));
3487 }
3488 session_id__ =
3489 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3490 ;
3491 }
3492 }
3493 }
3494 Ok(InsertNode {
3495 table_id: table_id__.unwrap_or_default(),
3496 table_version_id: table_version_id__.unwrap_or_default(),
3497 column_indices: column_indices__.unwrap_or_default(),
3498 default_columns: default_columns__,
3499 row_id_index: row_id_index__,
3500 returning: returning__.unwrap_or_default(),
3501 session_id: session_id__.unwrap_or_default(),
3502 })
3503 }
3504 }
3505 deserializer.deserialize_struct("batch_plan.InsertNode", FIELDS, GeneratedVisitor)
3506 }
3507}
3508impl serde::Serialize for LimitNode {
3509 #[allow(deprecated)]
3510 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3511 where
3512 S: serde::Serializer,
3513 {
3514 use serde::ser::SerializeStruct;
3515 let mut len = 0;
3516 if self.limit != 0 {
3517 len += 1;
3518 }
3519 if self.offset != 0 {
3520 len += 1;
3521 }
3522 let mut struct_ser = serializer.serialize_struct("batch_plan.LimitNode", len)?;
3523 if self.limit != 0 {
3524 #[allow(clippy::needless_borrow)]
3525 #[allow(clippy::needless_borrows_for_generic_args)]
3526 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
3527 }
3528 if self.offset != 0 {
3529 #[allow(clippy::needless_borrow)]
3530 #[allow(clippy::needless_borrows_for_generic_args)]
3531 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
3532 }
3533 struct_ser.end()
3534 }
3535}
3536impl<'de> serde::Deserialize<'de> for LimitNode {
3537 #[allow(deprecated)]
3538 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3539 where
3540 D: serde::Deserializer<'de>,
3541 {
3542 const FIELDS: &[&str] = &[
3543 "limit",
3544 "offset",
3545 ];
3546
3547 #[allow(clippy::enum_variant_names)]
3548 enum GeneratedField {
3549 Limit,
3550 Offset,
3551 }
3552 impl<'de> serde::Deserialize<'de> for GeneratedField {
3553 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3554 where
3555 D: serde::Deserializer<'de>,
3556 {
3557 struct GeneratedVisitor;
3558
3559 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3560 type Value = GeneratedField;
3561
3562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3563 write!(formatter, "expected one of: {:?}", &FIELDS)
3564 }
3565
3566 #[allow(unused_variables)]
3567 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3568 where
3569 E: serde::de::Error,
3570 {
3571 match value {
3572 "limit" => Ok(GeneratedField::Limit),
3573 "offset" => Ok(GeneratedField::Offset),
3574 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3575 }
3576 }
3577 }
3578 deserializer.deserialize_identifier(GeneratedVisitor)
3579 }
3580 }
3581 struct GeneratedVisitor;
3582 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3583 type Value = LimitNode;
3584
3585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3586 formatter.write_str("struct batch_plan.LimitNode")
3587 }
3588
3589 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LimitNode, V::Error>
3590 where
3591 V: serde::de::MapAccess<'de>,
3592 {
3593 let mut limit__ = None;
3594 let mut offset__ = None;
3595 while let Some(k) = map_.next_key()? {
3596 match k {
3597 GeneratedField::Limit => {
3598 if limit__.is_some() {
3599 return Err(serde::de::Error::duplicate_field("limit"));
3600 }
3601 limit__ =
3602 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3603 ;
3604 }
3605 GeneratedField::Offset => {
3606 if offset__.is_some() {
3607 return Err(serde::de::Error::duplicate_field("offset"));
3608 }
3609 offset__ =
3610 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3611 ;
3612 }
3613 }
3614 }
3615 Ok(LimitNode {
3616 limit: limit__.unwrap_or_default(),
3617 offset: offset__.unwrap_or_default(),
3618 })
3619 }
3620 }
3621 deserializer.deserialize_struct("batch_plan.LimitNode", FIELDS, GeneratedVisitor)
3622 }
3623}
3624impl serde::Serialize for LocalExecutePlan {
3625 #[allow(deprecated)]
3626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3627 where
3628 S: serde::Serializer,
3629 {
3630 use serde::ser::SerializeStruct;
3631 let mut len = 0;
3632 if self.plan.is_some() {
3633 len += 1;
3634 }
3635 if self.epoch.is_some() {
3636 len += 1;
3637 }
3638 if !self.tracing_context.is_empty() {
3639 len += 1;
3640 }
3641 let mut struct_ser = serializer.serialize_struct("batch_plan.LocalExecutePlan", len)?;
3642 if let Some(v) = self.plan.as_ref() {
3643 struct_ser.serialize_field("plan", v)?;
3644 }
3645 if let Some(v) = self.epoch.as_ref() {
3646 struct_ser.serialize_field("epoch", v)?;
3647 }
3648 if !self.tracing_context.is_empty() {
3649 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
3650 }
3651 struct_ser.end()
3652 }
3653}
3654impl<'de> serde::Deserialize<'de> for LocalExecutePlan {
3655 #[allow(deprecated)]
3656 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3657 where
3658 D: serde::Deserializer<'de>,
3659 {
3660 const FIELDS: &[&str] = &[
3661 "plan",
3662 "epoch",
3663 "tracing_context",
3664 "tracingContext",
3665 ];
3666
3667 #[allow(clippy::enum_variant_names)]
3668 enum GeneratedField {
3669 Plan,
3670 Epoch,
3671 TracingContext,
3672 }
3673 impl<'de> serde::Deserialize<'de> for GeneratedField {
3674 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3675 where
3676 D: serde::Deserializer<'de>,
3677 {
3678 struct GeneratedVisitor;
3679
3680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3681 type Value = GeneratedField;
3682
3683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3684 write!(formatter, "expected one of: {:?}", &FIELDS)
3685 }
3686
3687 #[allow(unused_variables)]
3688 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3689 where
3690 E: serde::de::Error,
3691 {
3692 match value {
3693 "plan" => Ok(GeneratedField::Plan),
3694 "epoch" => Ok(GeneratedField::Epoch),
3695 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
3696 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3697 }
3698 }
3699 }
3700 deserializer.deserialize_identifier(GeneratedVisitor)
3701 }
3702 }
3703 struct GeneratedVisitor;
3704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3705 type Value = LocalExecutePlan;
3706
3707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3708 formatter.write_str("struct batch_plan.LocalExecutePlan")
3709 }
3710
3711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalExecutePlan, V::Error>
3712 where
3713 V: serde::de::MapAccess<'de>,
3714 {
3715 let mut plan__ = None;
3716 let mut epoch__ = None;
3717 let mut tracing_context__ = None;
3718 while let Some(k) = map_.next_key()? {
3719 match k {
3720 GeneratedField::Plan => {
3721 if plan__.is_some() {
3722 return Err(serde::de::Error::duplicate_field("plan"));
3723 }
3724 plan__ = map_.next_value()?;
3725 }
3726 GeneratedField::Epoch => {
3727 if epoch__.is_some() {
3728 return Err(serde::de::Error::duplicate_field("epoch"));
3729 }
3730 epoch__ = map_.next_value()?;
3731 }
3732 GeneratedField::TracingContext => {
3733 if tracing_context__.is_some() {
3734 return Err(serde::de::Error::duplicate_field("tracingContext"));
3735 }
3736 tracing_context__ = Some(
3737 map_.next_value::<std::collections::HashMap<_, _>>()?
3738 );
3739 }
3740 }
3741 }
3742 Ok(LocalExecutePlan {
3743 plan: plan__,
3744 epoch: epoch__,
3745 tracing_context: tracing_context__.unwrap_or_default(),
3746 })
3747 }
3748 }
3749 deserializer.deserialize_struct("batch_plan.LocalExecutePlan", FIELDS, GeneratedVisitor)
3750 }
3751}
3752impl serde::Serialize for LocalLookupJoinNode {
3753 #[allow(deprecated)]
3754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3755 where
3756 S: serde::Serializer,
3757 {
3758 use serde::ser::SerializeStruct;
3759 let mut len = 0;
3760 if self.join_type != 0 {
3761 len += 1;
3762 }
3763 if self.condition.is_some() {
3764 len += 1;
3765 }
3766 if !self.outer_side_key.is_empty() {
3767 len += 1;
3768 }
3769 if !self.inner_side_key.is_empty() {
3770 len += 1;
3771 }
3772 if self.lookup_prefix_len != 0 {
3773 len += 1;
3774 }
3775 if self.inner_side_table_desc.is_some() {
3776 len += 1;
3777 }
3778 if !self.inner_side_vnode_mapping.is_empty() {
3779 len += 1;
3780 }
3781 if !self.inner_side_column_ids.is_empty() {
3782 len += 1;
3783 }
3784 if !self.output_indices.is_empty() {
3785 len += 1;
3786 }
3787 if !self.worker_nodes.is_empty() {
3788 len += 1;
3789 }
3790 if !self.null_safe.is_empty() {
3791 len += 1;
3792 }
3793 if self.as_of.is_some() {
3794 len += 1;
3795 }
3796 if self.asof_desc.is_some() {
3797 len += 1;
3798 }
3799 let mut struct_ser = serializer.serialize_struct("batch_plan.LocalLookupJoinNode", len)?;
3800 if self.join_type != 0 {
3801 let v = super::plan_common::JoinType::try_from(self.join_type)
3802 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3803 struct_ser.serialize_field("joinType", &v)?;
3804 }
3805 if let Some(v) = self.condition.as_ref() {
3806 struct_ser.serialize_field("condition", v)?;
3807 }
3808 if !self.outer_side_key.is_empty() {
3809 struct_ser.serialize_field("outerSideKey", &self.outer_side_key)?;
3810 }
3811 if !self.inner_side_key.is_empty() {
3812 struct_ser.serialize_field("innerSideKey", &self.inner_side_key)?;
3813 }
3814 if self.lookup_prefix_len != 0 {
3815 struct_ser.serialize_field("lookupPrefixLen", &self.lookup_prefix_len)?;
3816 }
3817 if let Some(v) = self.inner_side_table_desc.as_ref() {
3818 struct_ser.serialize_field("innerSideTableDesc", v)?;
3819 }
3820 if !self.inner_side_vnode_mapping.is_empty() {
3821 struct_ser.serialize_field("innerSideVnodeMapping", &self.inner_side_vnode_mapping.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3822 }
3823 if !self.inner_side_column_ids.is_empty() {
3824 struct_ser.serialize_field("innerSideColumnIds", &self.inner_side_column_ids)?;
3825 }
3826 if !self.output_indices.is_empty() {
3827 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3828 }
3829 if !self.worker_nodes.is_empty() {
3830 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
3831 }
3832 if !self.null_safe.is_empty() {
3833 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
3834 }
3835 if let Some(v) = self.as_of.as_ref() {
3836 struct_ser.serialize_field("asOf", v)?;
3837 }
3838 if let Some(v) = self.asof_desc.as_ref() {
3839 struct_ser.serialize_field("asofDesc", v)?;
3840 }
3841 struct_ser.end()
3842 }
3843}
3844impl<'de> serde::Deserialize<'de> for LocalLookupJoinNode {
3845 #[allow(deprecated)]
3846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3847 where
3848 D: serde::Deserializer<'de>,
3849 {
3850 const FIELDS: &[&str] = &[
3851 "join_type",
3852 "joinType",
3853 "condition",
3854 "outer_side_key",
3855 "outerSideKey",
3856 "inner_side_key",
3857 "innerSideKey",
3858 "lookup_prefix_len",
3859 "lookupPrefixLen",
3860 "inner_side_table_desc",
3861 "innerSideTableDesc",
3862 "inner_side_vnode_mapping",
3863 "innerSideVnodeMapping",
3864 "inner_side_column_ids",
3865 "innerSideColumnIds",
3866 "output_indices",
3867 "outputIndices",
3868 "worker_nodes",
3869 "workerNodes",
3870 "null_safe",
3871 "nullSafe",
3872 "as_of",
3873 "asOf",
3874 "asof_desc",
3875 "asofDesc",
3876 ];
3877
3878 #[allow(clippy::enum_variant_names)]
3879 enum GeneratedField {
3880 JoinType,
3881 Condition,
3882 OuterSideKey,
3883 InnerSideKey,
3884 LookupPrefixLen,
3885 InnerSideTableDesc,
3886 InnerSideVnodeMapping,
3887 InnerSideColumnIds,
3888 OutputIndices,
3889 WorkerNodes,
3890 NullSafe,
3891 AsOf,
3892 AsofDesc,
3893 }
3894 impl<'de> serde::Deserialize<'de> for GeneratedField {
3895 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3896 where
3897 D: serde::Deserializer<'de>,
3898 {
3899 struct GeneratedVisitor;
3900
3901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3902 type Value = GeneratedField;
3903
3904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3905 write!(formatter, "expected one of: {:?}", &FIELDS)
3906 }
3907
3908 #[allow(unused_variables)]
3909 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3910 where
3911 E: serde::de::Error,
3912 {
3913 match value {
3914 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3915 "condition" => Ok(GeneratedField::Condition),
3916 "outerSideKey" | "outer_side_key" => Ok(GeneratedField::OuterSideKey),
3917 "innerSideKey" | "inner_side_key" => Ok(GeneratedField::InnerSideKey),
3918 "lookupPrefixLen" | "lookup_prefix_len" => Ok(GeneratedField::LookupPrefixLen),
3919 "innerSideTableDesc" | "inner_side_table_desc" => Ok(GeneratedField::InnerSideTableDesc),
3920 "innerSideVnodeMapping" | "inner_side_vnode_mapping" => Ok(GeneratedField::InnerSideVnodeMapping),
3921 "innerSideColumnIds" | "inner_side_column_ids" => Ok(GeneratedField::InnerSideColumnIds),
3922 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3923 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
3924 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
3925 "asOf" | "as_of" => Ok(GeneratedField::AsOf),
3926 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
3927 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3928 }
3929 }
3930 }
3931 deserializer.deserialize_identifier(GeneratedVisitor)
3932 }
3933 }
3934 struct GeneratedVisitor;
3935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3936 type Value = LocalLookupJoinNode;
3937
3938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3939 formatter.write_str("struct batch_plan.LocalLookupJoinNode")
3940 }
3941
3942 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalLookupJoinNode, V::Error>
3943 where
3944 V: serde::de::MapAccess<'de>,
3945 {
3946 let mut join_type__ = None;
3947 let mut condition__ = None;
3948 let mut outer_side_key__ = None;
3949 let mut inner_side_key__ = None;
3950 let mut lookup_prefix_len__ = None;
3951 let mut inner_side_table_desc__ = None;
3952 let mut inner_side_vnode_mapping__ = None;
3953 let mut inner_side_column_ids__ = None;
3954 let mut output_indices__ = None;
3955 let mut worker_nodes__ = None;
3956 let mut null_safe__ = None;
3957 let mut as_of__ = None;
3958 let mut asof_desc__ = None;
3959 while let Some(k) = map_.next_key()? {
3960 match k {
3961 GeneratedField::JoinType => {
3962 if join_type__.is_some() {
3963 return Err(serde::de::Error::duplicate_field("joinType"));
3964 }
3965 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3966 }
3967 GeneratedField::Condition => {
3968 if condition__.is_some() {
3969 return Err(serde::de::Error::duplicate_field("condition"));
3970 }
3971 condition__ = map_.next_value()?;
3972 }
3973 GeneratedField::OuterSideKey => {
3974 if outer_side_key__.is_some() {
3975 return Err(serde::de::Error::duplicate_field("outerSideKey"));
3976 }
3977 outer_side_key__ =
3978 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3979 .into_iter().map(|x| x.0).collect())
3980 ;
3981 }
3982 GeneratedField::InnerSideKey => {
3983 if inner_side_key__.is_some() {
3984 return Err(serde::de::Error::duplicate_field("innerSideKey"));
3985 }
3986 inner_side_key__ =
3987 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3988 .into_iter().map(|x| x.0).collect())
3989 ;
3990 }
3991 GeneratedField::LookupPrefixLen => {
3992 if lookup_prefix_len__.is_some() {
3993 return Err(serde::de::Error::duplicate_field("lookupPrefixLen"));
3994 }
3995 lookup_prefix_len__ =
3996 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3997 ;
3998 }
3999 GeneratedField::InnerSideTableDesc => {
4000 if inner_side_table_desc__.is_some() {
4001 return Err(serde::de::Error::duplicate_field("innerSideTableDesc"));
4002 }
4003 inner_side_table_desc__ = map_.next_value()?;
4004 }
4005 GeneratedField::InnerSideVnodeMapping => {
4006 if inner_side_vnode_mapping__.is_some() {
4007 return Err(serde::de::Error::duplicate_field("innerSideVnodeMapping"));
4008 }
4009 inner_side_vnode_mapping__ =
4010 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4011 .into_iter().map(|x| x.0).collect())
4012 ;
4013 }
4014 GeneratedField::InnerSideColumnIds => {
4015 if inner_side_column_ids__.is_some() {
4016 return Err(serde::de::Error::duplicate_field("innerSideColumnIds"));
4017 }
4018 inner_side_column_ids__ =
4019 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4020 .into_iter().map(|x| x.0).collect())
4021 ;
4022 }
4023 GeneratedField::OutputIndices => {
4024 if output_indices__.is_some() {
4025 return Err(serde::de::Error::duplicate_field("outputIndices"));
4026 }
4027 output_indices__ =
4028 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4029 .into_iter().map(|x| x.0).collect())
4030 ;
4031 }
4032 GeneratedField::WorkerNodes => {
4033 if worker_nodes__.is_some() {
4034 return Err(serde::de::Error::duplicate_field("workerNodes"));
4035 }
4036 worker_nodes__ = Some(map_.next_value()?);
4037 }
4038 GeneratedField::NullSafe => {
4039 if null_safe__.is_some() {
4040 return Err(serde::de::Error::duplicate_field("nullSafe"));
4041 }
4042 null_safe__ = Some(map_.next_value()?);
4043 }
4044 GeneratedField::AsOf => {
4045 if as_of__.is_some() {
4046 return Err(serde::de::Error::duplicate_field("asOf"));
4047 }
4048 as_of__ = map_.next_value()?;
4049 }
4050 GeneratedField::AsofDesc => {
4051 if asof_desc__.is_some() {
4052 return Err(serde::de::Error::duplicate_field("asofDesc"));
4053 }
4054 asof_desc__ = map_.next_value()?;
4055 }
4056 }
4057 }
4058 Ok(LocalLookupJoinNode {
4059 join_type: join_type__.unwrap_or_default(),
4060 condition: condition__,
4061 outer_side_key: outer_side_key__.unwrap_or_default(),
4062 inner_side_key: inner_side_key__.unwrap_or_default(),
4063 lookup_prefix_len: lookup_prefix_len__.unwrap_or_default(),
4064 inner_side_table_desc: inner_side_table_desc__,
4065 inner_side_vnode_mapping: inner_side_vnode_mapping__.unwrap_or_default(),
4066 inner_side_column_ids: inner_side_column_ids__.unwrap_or_default(),
4067 output_indices: output_indices__.unwrap_or_default(),
4068 worker_nodes: worker_nodes__.unwrap_or_default(),
4069 null_safe: null_safe__.unwrap_or_default(),
4070 as_of: as_of__,
4071 asof_desc: asof_desc__,
4072 })
4073 }
4074 }
4075 deserializer.deserialize_struct("batch_plan.LocalLookupJoinNode", FIELDS, GeneratedVisitor)
4076 }
4077}
4078impl serde::Serialize for LogRowSeqScanNode {
4079 #[allow(deprecated)]
4080 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4081 where
4082 S: serde::Serializer,
4083 {
4084 use serde::ser::SerializeStruct;
4085 let mut len = 0;
4086 if self.table_desc.is_some() {
4087 len += 1;
4088 }
4089 if !self.column_ids.is_empty() {
4090 len += 1;
4091 }
4092 if self.vnode_bitmap.is_some() {
4093 len += 1;
4094 }
4095 if self.old_epoch.is_some() {
4096 len += 1;
4097 }
4098 if self.new_epoch.is_some() {
4099 len += 1;
4100 }
4101 if self.ordered {
4102 len += 1;
4103 }
4104 if self.scan_range.is_some() {
4105 len += 1;
4106 }
4107 let mut struct_ser = serializer.serialize_struct("batch_plan.LogRowSeqScanNode", len)?;
4108 if let Some(v) = self.table_desc.as_ref() {
4109 struct_ser.serialize_field("tableDesc", v)?;
4110 }
4111 if !self.column_ids.is_empty() {
4112 struct_ser.serialize_field("columnIds", &self.column_ids)?;
4113 }
4114 if let Some(v) = self.vnode_bitmap.as_ref() {
4115 struct_ser.serialize_field("vnodeBitmap", v)?;
4116 }
4117 if let Some(v) = self.old_epoch.as_ref() {
4118 struct_ser.serialize_field("oldEpoch", v)?;
4119 }
4120 if let Some(v) = self.new_epoch.as_ref() {
4121 struct_ser.serialize_field("newEpoch", v)?;
4122 }
4123 if self.ordered {
4124 struct_ser.serialize_field("ordered", &self.ordered)?;
4125 }
4126 if let Some(v) = self.scan_range.as_ref() {
4127 struct_ser.serialize_field("scanRange", v)?;
4128 }
4129 struct_ser.end()
4130 }
4131}
4132impl<'de> serde::Deserialize<'de> for LogRowSeqScanNode {
4133 #[allow(deprecated)]
4134 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4135 where
4136 D: serde::Deserializer<'de>,
4137 {
4138 const FIELDS: &[&str] = &[
4139 "table_desc",
4140 "tableDesc",
4141 "column_ids",
4142 "columnIds",
4143 "vnode_bitmap",
4144 "vnodeBitmap",
4145 "old_epoch",
4146 "oldEpoch",
4147 "new_epoch",
4148 "newEpoch",
4149 "ordered",
4150 "scan_range",
4151 "scanRange",
4152 ];
4153
4154 #[allow(clippy::enum_variant_names)]
4155 enum GeneratedField {
4156 TableDesc,
4157 ColumnIds,
4158 VnodeBitmap,
4159 OldEpoch,
4160 NewEpoch,
4161 Ordered,
4162 ScanRange,
4163 }
4164 impl<'de> serde::Deserialize<'de> for GeneratedField {
4165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4166 where
4167 D: serde::Deserializer<'de>,
4168 {
4169 struct GeneratedVisitor;
4170
4171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4172 type Value = GeneratedField;
4173
4174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4175 write!(formatter, "expected one of: {:?}", &FIELDS)
4176 }
4177
4178 #[allow(unused_variables)]
4179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4180 where
4181 E: serde::de::Error,
4182 {
4183 match value {
4184 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
4185 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
4186 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
4187 "oldEpoch" | "old_epoch" => Ok(GeneratedField::OldEpoch),
4188 "newEpoch" | "new_epoch" => Ok(GeneratedField::NewEpoch),
4189 "ordered" => Ok(GeneratedField::Ordered),
4190 "scanRange" | "scan_range" => Ok(GeneratedField::ScanRange),
4191 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4192 }
4193 }
4194 }
4195 deserializer.deserialize_identifier(GeneratedVisitor)
4196 }
4197 }
4198 struct GeneratedVisitor;
4199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4200 type Value = LogRowSeqScanNode;
4201
4202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4203 formatter.write_str("struct batch_plan.LogRowSeqScanNode")
4204 }
4205
4206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LogRowSeqScanNode, V::Error>
4207 where
4208 V: serde::de::MapAccess<'de>,
4209 {
4210 let mut table_desc__ = None;
4211 let mut column_ids__ = None;
4212 let mut vnode_bitmap__ = None;
4213 let mut old_epoch__ = None;
4214 let mut new_epoch__ = None;
4215 let mut ordered__ = None;
4216 let mut scan_range__ = None;
4217 while let Some(k) = map_.next_key()? {
4218 match k {
4219 GeneratedField::TableDesc => {
4220 if table_desc__.is_some() {
4221 return Err(serde::de::Error::duplicate_field("tableDesc"));
4222 }
4223 table_desc__ = map_.next_value()?;
4224 }
4225 GeneratedField::ColumnIds => {
4226 if column_ids__.is_some() {
4227 return Err(serde::de::Error::duplicate_field("columnIds"));
4228 }
4229 column_ids__ =
4230 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4231 .into_iter().map(|x| x.0).collect())
4232 ;
4233 }
4234 GeneratedField::VnodeBitmap => {
4235 if vnode_bitmap__.is_some() {
4236 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
4237 }
4238 vnode_bitmap__ = map_.next_value()?;
4239 }
4240 GeneratedField::OldEpoch => {
4241 if old_epoch__.is_some() {
4242 return Err(serde::de::Error::duplicate_field("oldEpoch"));
4243 }
4244 old_epoch__ = map_.next_value()?;
4245 }
4246 GeneratedField::NewEpoch => {
4247 if new_epoch__.is_some() {
4248 return Err(serde::de::Error::duplicate_field("newEpoch"));
4249 }
4250 new_epoch__ = map_.next_value()?;
4251 }
4252 GeneratedField::Ordered => {
4253 if ordered__.is_some() {
4254 return Err(serde::de::Error::duplicate_field("ordered"));
4255 }
4256 ordered__ = Some(map_.next_value()?);
4257 }
4258 GeneratedField::ScanRange => {
4259 if scan_range__.is_some() {
4260 return Err(serde::de::Error::duplicate_field("scanRange"));
4261 }
4262 scan_range__ = map_.next_value()?;
4263 }
4264 }
4265 }
4266 Ok(LogRowSeqScanNode {
4267 table_desc: table_desc__,
4268 column_ids: column_ids__.unwrap_or_default(),
4269 vnode_bitmap: vnode_bitmap__,
4270 old_epoch: old_epoch__,
4271 new_epoch: new_epoch__,
4272 ordered: ordered__.unwrap_or_default(),
4273 scan_range: scan_range__,
4274 })
4275 }
4276 }
4277 deserializer.deserialize_struct("batch_plan.LogRowSeqScanNode", FIELDS, GeneratedVisitor)
4278 }
4279}
4280impl serde::Serialize for MaxOneRowNode {
4281 #[allow(deprecated)]
4282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4283 where
4284 S: serde::Serializer,
4285 {
4286 use serde::ser::SerializeStruct;
4287 let len = 0;
4288 let struct_ser = serializer.serialize_struct("batch_plan.MaxOneRowNode", len)?;
4289 struct_ser.end()
4290 }
4291}
4292impl<'de> serde::Deserialize<'de> for MaxOneRowNode {
4293 #[allow(deprecated)]
4294 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4295 where
4296 D: serde::Deserializer<'de>,
4297 {
4298 const FIELDS: &[&str] = &[
4299 ];
4300
4301 #[allow(clippy::enum_variant_names)]
4302 enum GeneratedField {
4303 }
4304 impl<'de> serde::Deserialize<'de> for GeneratedField {
4305 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4306 where
4307 D: serde::Deserializer<'de>,
4308 {
4309 struct GeneratedVisitor;
4310
4311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4312 type Value = GeneratedField;
4313
4314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4315 write!(formatter, "expected one of: {:?}", &FIELDS)
4316 }
4317
4318 #[allow(unused_variables)]
4319 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4320 where
4321 E: serde::de::Error,
4322 {
4323 Err(serde::de::Error::unknown_field(value, FIELDS))
4324 }
4325 }
4326 deserializer.deserialize_identifier(GeneratedVisitor)
4327 }
4328 }
4329 struct GeneratedVisitor;
4330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4331 type Value = MaxOneRowNode;
4332
4333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4334 formatter.write_str("struct batch_plan.MaxOneRowNode")
4335 }
4336
4337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaxOneRowNode, V::Error>
4338 where
4339 V: serde::de::MapAccess<'de>,
4340 {
4341 while map_.next_key::<GeneratedField>()?.is_some() {
4342 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4343 }
4344 Ok(MaxOneRowNode {
4345 })
4346 }
4347 }
4348 deserializer.deserialize_struct("batch_plan.MaxOneRowNode", FIELDS, GeneratedVisitor)
4349 }
4350}
4351impl serde::Serialize for MergeSortExchangeNode {
4352 #[allow(deprecated)]
4353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4354 where
4355 S: serde::Serializer,
4356 {
4357 use serde::ser::SerializeStruct;
4358 let mut len = 0;
4359 if self.exchange.is_some() {
4360 len += 1;
4361 }
4362 if !self.column_orders.is_empty() {
4363 len += 1;
4364 }
4365 let mut struct_ser = serializer.serialize_struct("batch_plan.MergeSortExchangeNode", len)?;
4366 if let Some(v) = self.exchange.as_ref() {
4367 struct_ser.serialize_field("exchange", v)?;
4368 }
4369 if !self.column_orders.is_empty() {
4370 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
4371 }
4372 struct_ser.end()
4373 }
4374}
4375impl<'de> serde::Deserialize<'de> for MergeSortExchangeNode {
4376 #[allow(deprecated)]
4377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4378 where
4379 D: serde::Deserializer<'de>,
4380 {
4381 const FIELDS: &[&str] = &[
4382 "exchange",
4383 "column_orders",
4384 "columnOrders",
4385 ];
4386
4387 #[allow(clippy::enum_variant_names)]
4388 enum GeneratedField {
4389 Exchange,
4390 ColumnOrders,
4391 }
4392 impl<'de> serde::Deserialize<'de> for GeneratedField {
4393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4394 where
4395 D: serde::Deserializer<'de>,
4396 {
4397 struct GeneratedVisitor;
4398
4399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4400 type Value = GeneratedField;
4401
4402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4403 write!(formatter, "expected one of: {:?}", &FIELDS)
4404 }
4405
4406 #[allow(unused_variables)]
4407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4408 where
4409 E: serde::de::Error,
4410 {
4411 match value {
4412 "exchange" => Ok(GeneratedField::Exchange),
4413 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
4414 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4415 }
4416 }
4417 }
4418 deserializer.deserialize_identifier(GeneratedVisitor)
4419 }
4420 }
4421 struct GeneratedVisitor;
4422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4423 type Value = MergeSortExchangeNode;
4424
4425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4426 formatter.write_str("struct batch_plan.MergeSortExchangeNode")
4427 }
4428
4429 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeSortExchangeNode, V::Error>
4430 where
4431 V: serde::de::MapAccess<'de>,
4432 {
4433 let mut exchange__ = None;
4434 let mut column_orders__ = None;
4435 while let Some(k) = map_.next_key()? {
4436 match k {
4437 GeneratedField::Exchange => {
4438 if exchange__.is_some() {
4439 return Err(serde::de::Error::duplicate_field("exchange"));
4440 }
4441 exchange__ = map_.next_value()?;
4442 }
4443 GeneratedField::ColumnOrders => {
4444 if column_orders__.is_some() {
4445 return Err(serde::de::Error::duplicate_field("columnOrders"));
4446 }
4447 column_orders__ = Some(map_.next_value()?);
4448 }
4449 }
4450 }
4451 Ok(MergeSortExchangeNode {
4452 exchange: exchange__,
4453 column_orders: column_orders__.unwrap_or_default(),
4454 })
4455 }
4456 }
4457 deserializer.deserialize_struct("batch_plan.MergeSortExchangeNode", FIELDS, GeneratedVisitor)
4458 }
4459}
4460impl serde::Serialize for MySqlQueryNode {
4461 #[allow(deprecated)]
4462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4463 where
4464 S: serde::Serializer,
4465 {
4466 use serde::ser::SerializeStruct;
4467 let mut len = 0;
4468 if !self.columns.is_empty() {
4469 len += 1;
4470 }
4471 if !self.hostname.is_empty() {
4472 len += 1;
4473 }
4474 if !self.port.is_empty() {
4475 len += 1;
4476 }
4477 if !self.username.is_empty() {
4478 len += 1;
4479 }
4480 if !self.password.is_empty() {
4481 len += 1;
4482 }
4483 if !self.database.is_empty() {
4484 len += 1;
4485 }
4486 if !self.query.is_empty() {
4487 len += 1;
4488 }
4489 let mut struct_ser = serializer.serialize_struct("batch_plan.MySqlQueryNode", len)?;
4490 if !self.columns.is_empty() {
4491 struct_ser.serialize_field("columns", &self.columns)?;
4492 }
4493 if !self.hostname.is_empty() {
4494 struct_ser.serialize_field("hostname", &self.hostname)?;
4495 }
4496 if !self.port.is_empty() {
4497 struct_ser.serialize_field("port", &self.port)?;
4498 }
4499 if !self.username.is_empty() {
4500 struct_ser.serialize_field("username", &self.username)?;
4501 }
4502 if !self.password.is_empty() {
4503 struct_ser.serialize_field("password", &self.password)?;
4504 }
4505 if !self.database.is_empty() {
4506 struct_ser.serialize_field("database", &self.database)?;
4507 }
4508 if !self.query.is_empty() {
4509 struct_ser.serialize_field("query", &self.query)?;
4510 }
4511 struct_ser.end()
4512 }
4513}
4514impl<'de> serde::Deserialize<'de> for MySqlQueryNode {
4515 #[allow(deprecated)]
4516 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4517 where
4518 D: serde::Deserializer<'de>,
4519 {
4520 const FIELDS: &[&str] = &[
4521 "columns",
4522 "hostname",
4523 "port",
4524 "username",
4525 "password",
4526 "database",
4527 "query",
4528 ];
4529
4530 #[allow(clippy::enum_variant_names)]
4531 enum GeneratedField {
4532 Columns,
4533 Hostname,
4534 Port,
4535 Username,
4536 Password,
4537 Database,
4538 Query,
4539 }
4540 impl<'de> serde::Deserialize<'de> for GeneratedField {
4541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4542 where
4543 D: serde::Deserializer<'de>,
4544 {
4545 struct GeneratedVisitor;
4546
4547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4548 type Value = GeneratedField;
4549
4550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4551 write!(formatter, "expected one of: {:?}", &FIELDS)
4552 }
4553
4554 #[allow(unused_variables)]
4555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4556 where
4557 E: serde::de::Error,
4558 {
4559 match value {
4560 "columns" => Ok(GeneratedField::Columns),
4561 "hostname" => Ok(GeneratedField::Hostname),
4562 "port" => Ok(GeneratedField::Port),
4563 "username" => Ok(GeneratedField::Username),
4564 "password" => Ok(GeneratedField::Password),
4565 "database" => Ok(GeneratedField::Database),
4566 "query" => Ok(GeneratedField::Query),
4567 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4568 }
4569 }
4570 }
4571 deserializer.deserialize_identifier(GeneratedVisitor)
4572 }
4573 }
4574 struct GeneratedVisitor;
4575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4576 type Value = MySqlQueryNode;
4577
4578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4579 formatter.write_str("struct batch_plan.MySqlQueryNode")
4580 }
4581
4582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MySqlQueryNode, V::Error>
4583 where
4584 V: serde::de::MapAccess<'de>,
4585 {
4586 let mut columns__ = None;
4587 let mut hostname__ = None;
4588 let mut port__ = None;
4589 let mut username__ = None;
4590 let mut password__ = None;
4591 let mut database__ = None;
4592 let mut query__ = None;
4593 while let Some(k) = map_.next_key()? {
4594 match k {
4595 GeneratedField::Columns => {
4596 if columns__.is_some() {
4597 return Err(serde::de::Error::duplicate_field("columns"));
4598 }
4599 columns__ = Some(map_.next_value()?);
4600 }
4601 GeneratedField::Hostname => {
4602 if hostname__.is_some() {
4603 return Err(serde::de::Error::duplicate_field("hostname"));
4604 }
4605 hostname__ = Some(map_.next_value()?);
4606 }
4607 GeneratedField::Port => {
4608 if port__.is_some() {
4609 return Err(serde::de::Error::duplicate_field("port"));
4610 }
4611 port__ = Some(map_.next_value()?);
4612 }
4613 GeneratedField::Username => {
4614 if username__.is_some() {
4615 return Err(serde::de::Error::duplicate_field("username"));
4616 }
4617 username__ = Some(map_.next_value()?);
4618 }
4619 GeneratedField::Password => {
4620 if password__.is_some() {
4621 return Err(serde::de::Error::duplicate_field("password"));
4622 }
4623 password__ = Some(map_.next_value()?);
4624 }
4625 GeneratedField::Database => {
4626 if database__.is_some() {
4627 return Err(serde::de::Error::duplicate_field("database"));
4628 }
4629 database__ = Some(map_.next_value()?);
4630 }
4631 GeneratedField::Query => {
4632 if query__.is_some() {
4633 return Err(serde::de::Error::duplicate_field("query"));
4634 }
4635 query__ = Some(map_.next_value()?);
4636 }
4637 }
4638 }
4639 Ok(MySqlQueryNode {
4640 columns: columns__.unwrap_or_default(),
4641 hostname: hostname__.unwrap_or_default(),
4642 port: port__.unwrap_or_default(),
4643 username: username__.unwrap_or_default(),
4644 password: password__.unwrap_or_default(),
4645 database: database__.unwrap_or_default(),
4646 query: query__.unwrap_or_default(),
4647 })
4648 }
4649 }
4650 deserializer.deserialize_struct("batch_plan.MySqlQueryNode", FIELDS, GeneratedVisitor)
4651 }
4652}
4653impl serde::Serialize for NestedLoopJoinNode {
4654 #[allow(deprecated)]
4655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4656 where
4657 S: serde::Serializer,
4658 {
4659 use serde::ser::SerializeStruct;
4660 let mut len = 0;
4661 if self.join_type != 0 {
4662 len += 1;
4663 }
4664 if self.join_cond.is_some() {
4665 len += 1;
4666 }
4667 if !self.output_indices.is_empty() {
4668 len += 1;
4669 }
4670 let mut struct_ser = serializer.serialize_struct("batch_plan.NestedLoopJoinNode", len)?;
4671 if self.join_type != 0 {
4672 let v = super::plan_common::JoinType::try_from(self.join_type)
4673 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
4674 struct_ser.serialize_field("joinType", &v)?;
4675 }
4676 if let Some(v) = self.join_cond.as_ref() {
4677 struct_ser.serialize_field("joinCond", v)?;
4678 }
4679 if !self.output_indices.is_empty() {
4680 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
4681 }
4682 struct_ser.end()
4683 }
4684}
4685impl<'de> serde::Deserialize<'de> for NestedLoopJoinNode {
4686 #[allow(deprecated)]
4687 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4688 where
4689 D: serde::Deserializer<'de>,
4690 {
4691 const FIELDS: &[&str] = &[
4692 "join_type",
4693 "joinType",
4694 "join_cond",
4695 "joinCond",
4696 "output_indices",
4697 "outputIndices",
4698 ];
4699
4700 #[allow(clippy::enum_variant_names)]
4701 enum GeneratedField {
4702 JoinType,
4703 JoinCond,
4704 OutputIndices,
4705 }
4706 impl<'de> serde::Deserialize<'de> for GeneratedField {
4707 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4708 where
4709 D: serde::Deserializer<'de>,
4710 {
4711 struct GeneratedVisitor;
4712
4713 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4714 type Value = GeneratedField;
4715
4716 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4717 write!(formatter, "expected one of: {:?}", &FIELDS)
4718 }
4719
4720 #[allow(unused_variables)]
4721 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4722 where
4723 E: serde::de::Error,
4724 {
4725 match value {
4726 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
4727 "joinCond" | "join_cond" => Ok(GeneratedField::JoinCond),
4728 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
4729 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4730 }
4731 }
4732 }
4733 deserializer.deserialize_identifier(GeneratedVisitor)
4734 }
4735 }
4736 struct GeneratedVisitor;
4737 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4738 type Value = NestedLoopJoinNode;
4739
4740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4741 formatter.write_str("struct batch_plan.NestedLoopJoinNode")
4742 }
4743
4744 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NestedLoopJoinNode, V::Error>
4745 where
4746 V: serde::de::MapAccess<'de>,
4747 {
4748 let mut join_type__ = None;
4749 let mut join_cond__ = None;
4750 let mut output_indices__ = None;
4751 while let Some(k) = map_.next_key()? {
4752 match k {
4753 GeneratedField::JoinType => {
4754 if join_type__.is_some() {
4755 return Err(serde::de::Error::duplicate_field("joinType"));
4756 }
4757 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
4758 }
4759 GeneratedField::JoinCond => {
4760 if join_cond__.is_some() {
4761 return Err(serde::de::Error::duplicate_field("joinCond"));
4762 }
4763 join_cond__ = map_.next_value()?;
4764 }
4765 GeneratedField::OutputIndices => {
4766 if output_indices__.is_some() {
4767 return Err(serde::de::Error::duplicate_field("outputIndices"));
4768 }
4769 output_indices__ =
4770 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4771 .into_iter().map(|x| x.0).collect())
4772 ;
4773 }
4774 }
4775 }
4776 Ok(NestedLoopJoinNode {
4777 join_type: join_type__.unwrap_or_default(),
4778 join_cond: join_cond__,
4779 output_indices: output_indices__.unwrap_or_default(),
4780 })
4781 }
4782 }
4783 deserializer.deserialize_struct("batch_plan.NestedLoopJoinNode", FIELDS, GeneratedVisitor)
4784 }
4785}
4786impl serde::Serialize for PlanFragment {
4787 #[allow(deprecated)]
4788 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4789 where
4790 S: serde::Serializer,
4791 {
4792 use serde::ser::SerializeStruct;
4793 let mut len = 0;
4794 if self.root.is_some() {
4795 len += 1;
4796 }
4797 if self.exchange_info.is_some() {
4798 len += 1;
4799 }
4800 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanFragment", len)?;
4801 if let Some(v) = self.root.as_ref() {
4802 struct_ser.serialize_field("root", v)?;
4803 }
4804 if let Some(v) = self.exchange_info.as_ref() {
4805 struct_ser.serialize_field("exchangeInfo", v)?;
4806 }
4807 struct_ser.end()
4808 }
4809}
4810impl<'de> serde::Deserialize<'de> for PlanFragment {
4811 #[allow(deprecated)]
4812 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4813 where
4814 D: serde::Deserializer<'de>,
4815 {
4816 const FIELDS: &[&str] = &[
4817 "root",
4818 "exchange_info",
4819 "exchangeInfo",
4820 ];
4821
4822 #[allow(clippy::enum_variant_names)]
4823 enum GeneratedField {
4824 Root,
4825 ExchangeInfo,
4826 }
4827 impl<'de> serde::Deserialize<'de> for GeneratedField {
4828 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4829 where
4830 D: serde::Deserializer<'de>,
4831 {
4832 struct GeneratedVisitor;
4833
4834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4835 type Value = GeneratedField;
4836
4837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4838 write!(formatter, "expected one of: {:?}", &FIELDS)
4839 }
4840
4841 #[allow(unused_variables)]
4842 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4843 where
4844 E: serde::de::Error,
4845 {
4846 match value {
4847 "root" => Ok(GeneratedField::Root),
4848 "exchangeInfo" | "exchange_info" => Ok(GeneratedField::ExchangeInfo),
4849 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4850 }
4851 }
4852 }
4853 deserializer.deserialize_identifier(GeneratedVisitor)
4854 }
4855 }
4856 struct GeneratedVisitor;
4857 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4858 type Value = PlanFragment;
4859
4860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4861 formatter.write_str("struct batch_plan.PlanFragment")
4862 }
4863
4864 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanFragment, V::Error>
4865 where
4866 V: serde::de::MapAccess<'de>,
4867 {
4868 let mut root__ = None;
4869 let mut exchange_info__ = None;
4870 while let Some(k) = map_.next_key()? {
4871 match k {
4872 GeneratedField::Root => {
4873 if root__.is_some() {
4874 return Err(serde::de::Error::duplicate_field("root"));
4875 }
4876 root__ = map_.next_value()?;
4877 }
4878 GeneratedField::ExchangeInfo => {
4879 if exchange_info__.is_some() {
4880 return Err(serde::de::Error::duplicate_field("exchangeInfo"));
4881 }
4882 exchange_info__ = map_.next_value()?;
4883 }
4884 }
4885 }
4886 Ok(PlanFragment {
4887 root: root__,
4888 exchange_info: exchange_info__,
4889 })
4890 }
4891 }
4892 deserializer.deserialize_struct("batch_plan.PlanFragment", FIELDS, GeneratedVisitor)
4893 }
4894}
4895impl serde::Serialize for PlanNode {
4896 #[allow(deprecated)]
4897 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4898 where
4899 S: serde::Serializer,
4900 {
4901 use serde::ser::SerializeStruct;
4902 let mut len = 0;
4903 if !self.children.is_empty() {
4904 len += 1;
4905 }
4906 if !self.identity.is_empty() {
4907 len += 1;
4908 }
4909 if self.node_body.is_some() {
4910 len += 1;
4911 }
4912 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanNode", len)?;
4913 if !self.children.is_empty() {
4914 struct_ser.serialize_field("children", &self.children)?;
4915 }
4916 if !self.identity.is_empty() {
4917 struct_ser.serialize_field("identity", &self.identity)?;
4918 }
4919 if let Some(v) = self.node_body.as_ref() {
4920 match v {
4921 plan_node::NodeBody::Insert(v) => {
4922 struct_ser.serialize_field("insert", v)?;
4923 }
4924 plan_node::NodeBody::Delete(v) => {
4925 struct_ser.serialize_field("delete", v)?;
4926 }
4927 plan_node::NodeBody::Update(v) => {
4928 struct_ser.serialize_field("update", v)?;
4929 }
4930 plan_node::NodeBody::Project(v) => {
4931 struct_ser.serialize_field("project", v)?;
4932 }
4933 plan_node::NodeBody::HashAgg(v) => {
4934 struct_ser.serialize_field("hashAgg", v)?;
4935 }
4936 plan_node::NodeBody::Filter(v) => {
4937 struct_ser.serialize_field("filter", v)?;
4938 }
4939 plan_node::NodeBody::Exchange(v) => {
4940 struct_ser.serialize_field("exchange", v)?;
4941 }
4942 plan_node::NodeBody::Sort(v) => {
4943 struct_ser.serialize_field("sort", v)?;
4944 }
4945 plan_node::NodeBody::NestedLoopJoin(v) => {
4946 struct_ser.serialize_field("nestedLoopJoin", v)?;
4947 }
4948 plan_node::NodeBody::TopN(v) => {
4949 struct_ser.serialize_field("topN", v)?;
4950 }
4951 plan_node::NodeBody::SortAgg(v) => {
4952 struct_ser.serialize_field("sortAgg", v)?;
4953 }
4954 plan_node::NodeBody::RowSeqScan(v) => {
4955 struct_ser.serialize_field("rowSeqScan", v)?;
4956 }
4957 plan_node::NodeBody::Limit(v) => {
4958 struct_ser.serialize_field("limit", v)?;
4959 }
4960 plan_node::NodeBody::Values(v) => {
4961 struct_ser.serialize_field("values", v)?;
4962 }
4963 plan_node::NodeBody::HashJoin(v) => {
4964 struct_ser.serialize_field("hashJoin", v)?;
4965 }
4966 plan_node::NodeBody::MergeSortExchange(v) => {
4967 struct_ser.serialize_field("mergeSortExchange", v)?;
4968 }
4969 plan_node::NodeBody::HopWindow(v) => {
4970 struct_ser.serialize_field("hopWindow", v)?;
4971 }
4972 plan_node::NodeBody::TableFunction(v) => {
4973 struct_ser.serialize_field("tableFunction", v)?;
4974 }
4975 plan_node::NodeBody::SysRowSeqScan(v) => {
4976 struct_ser.serialize_field("sysRowSeqScan", v)?;
4977 }
4978 plan_node::NodeBody::Expand(v) => {
4979 struct_ser.serialize_field("expand", v)?;
4980 }
4981 plan_node::NodeBody::LocalLookupJoin(v) => {
4982 struct_ser.serialize_field("localLookupJoin", v)?;
4983 }
4984 plan_node::NodeBody::ProjectSet(v) => {
4985 struct_ser.serialize_field("projectSet", v)?;
4986 }
4987 plan_node::NodeBody::Union(v) => {
4988 struct_ser.serialize_field("union", v)?;
4989 }
4990 plan_node::NodeBody::GroupTopN(v) => {
4991 struct_ser.serialize_field("groupTopN", v)?;
4992 }
4993 plan_node::NodeBody::DistributedLookupJoin(v) => {
4994 struct_ser.serialize_field("distributedLookupJoin", v)?;
4995 }
4996 plan_node::NodeBody::Source(v) => {
4997 struct_ser.serialize_field("source", v)?;
4998 }
4999 plan_node::NodeBody::SortOverWindow(v) => {
5000 struct_ser.serialize_field("sortOverWindow", v)?;
5001 }
5002 plan_node::NodeBody::MaxOneRow(v) => {
5003 struct_ser.serialize_field("maxOneRow", v)?;
5004 }
5005 plan_node::NodeBody::LogRowSeqScan(v) => {
5006 struct_ser.serialize_field("logRowSeqScan", v)?;
5007 }
5008 plan_node::NodeBody::FileScan(v) => {
5009 struct_ser.serialize_field("fileScan", v)?;
5010 }
5011 plan_node::NodeBody::IcebergScan(v) => {
5012 struct_ser.serialize_field("icebergScan", v)?;
5013 }
5014 plan_node::NodeBody::PostgresQuery(v) => {
5015 struct_ser.serialize_field("postgresQuery", v)?;
5016 }
5017 plan_node::NodeBody::MysqlQuery(v) => {
5018 struct_ser.serialize_field("mysqlQuery", v)?;
5019 }
5020 plan_node::NodeBody::GcsFileScan(v) => {
5021 struct_ser.serialize_field("gcsFileScan", v)?;
5022 }
5023 plan_node::NodeBody::AzblobFileScan(v) => {
5024 struct_ser.serialize_field("azblobFileScan", v)?;
5025 }
5026 plan_node::NodeBody::BlockExecutor(v) => {
5027 struct_ser.serialize_field("blockExecutor", v)?;
5028 }
5029 plan_node::NodeBody::BusyLoopExecutor(v) => {
5030 struct_ser.serialize_field("busyLoopExecutor", v)?;
5031 }
5032 }
5033 }
5034 struct_ser.end()
5035 }
5036}
5037impl<'de> serde::Deserialize<'de> for PlanNode {
5038 #[allow(deprecated)]
5039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5040 where
5041 D: serde::Deserializer<'de>,
5042 {
5043 const FIELDS: &[&str] = &[
5044 "children",
5045 "identity",
5046 "insert",
5047 "delete",
5048 "update",
5049 "project",
5050 "hash_agg",
5051 "hashAgg",
5052 "filter",
5053 "exchange",
5054 "sort",
5055 "nested_loop_join",
5056 "nestedLoopJoin",
5057 "top_n",
5058 "topN",
5059 "sort_agg",
5060 "sortAgg",
5061 "row_seq_scan",
5062 "rowSeqScan",
5063 "limit",
5064 "values",
5065 "hash_join",
5066 "hashJoin",
5067 "merge_sort_exchange",
5068 "mergeSortExchange",
5069 "hop_window",
5070 "hopWindow",
5071 "table_function",
5072 "tableFunction",
5073 "sys_row_seq_scan",
5074 "sysRowSeqScan",
5075 "expand",
5076 "local_lookup_join",
5077 "localLookupJoin",
5078 "project_set",
5079 "projectSet",
5080 "union",
5081 "group_top_n",
5082 "groupTopN",
5083 "distributed_lookup_join",
5084 "distributedLookupJoin",
5085 "source",
5086 "sort_over_window",
5087 "sortOverWindow",
5088 "max_one_row",
5089 "maxOneRow",
5090 "log_row_seq_scan",
5091 "logRowSeqScan",
5092 "file_scan",
5093 "fileScan",
5094 "iceberg_scan",
5095 "icebergScan",
5096 "postgres_query",
5097 "postgresQuery",
5098 "mysql_query",
5099 "mysqlQuery",
5100 "gcs_file_scan",
5101 "gcsFileScan",
5102 "azblob_file_scan",
5103 "azblobFileScan",
5104 "block_executor",
5105 "blockExecutor",
5106 "busy_loop_executor",
5107 "busyLoopExecutor",
5108 ];
5109
5110 #[allow(clippy::enum_variant_names)]
5111 enum GeneratedField {
5112 Children,
5113 Identity,
5114 Insert,
5115 Delete,
5116 Update,
5117 Project,
5118 HashAgg,
5119 Filter,
5120 Exchange,
5121 Sort,
5122 NestedLoopJoin,
5123 TopN,
5124 SortAgg,
5125 RowSeqScan,
5126 Limit,
5127 Values,
5128 HashJoin,
5129 MergeSortExchange,
5130 HopWindow,
5131 TableFunction,
5132 SysRowSeqScan,
5133 Expand,
5134 LocalLookupJoin,
5135 ProjectSet,
5136 Union,
5137 GroupTopN,
5138 DistributedLookupJoin,
5139 Source,
5140 SortOverWindow,
5141 MaxOneRow,
5142 LogRowSeqScan,
5143 FileScan,
5144 IcebergScan,
5145 PostgresQuery,
5146 MysqlQuery,
5147 GcsFileScan,
5148 AzblobFileScan,
5149 BlockExecutor,
5150 BusyLoopExecutor,
5151 }
5152 impl<'de> serde::Deserialize<'de> for GeneratedField {
5153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5154 where
5155 D: serde::Deserializer<'de>,
5156 {
5157 struct GeneratedVisitor;
5158
5159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5160 type Value = GeneratedField;
5161
5162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5163 write!(formatter, "expected one of: {:?}", &FIELDS)
5164 }
5165
5166 #[allow(unused_variables)]
5167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5168 where
5169 E: serde::de::Error,
5170 {
5171 match value {
5172 "children" => Ok(GeneratedField::Children),
5173 "identity" => Ok(GeneratedField::Identity),
5174 "insert" => Ok(GeneratedField::Insert),
5175 "delete" => Ok(GeneratedField::Delete),
5176 "update" => Ok(GeneratedField::Update),
5177 "project" => Ok(GeneratedField::Project),
5178 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
5179 "filter" => Ok(GeneratedField::Filter),
5180 "exchange" => Ok(GeneratedField::Exchange),
5181 "sort" => Ok(GeneratedField::Sort),
5182 "nestedLoopJoin" | "nested_loop_join" => Ok(GeneratedField::NestedLoopJoin),
5183 "topN" | "top_n" => Ok(GeneratedField::TopN),
5184 "sortAgg" | "sort_agg" => Ok(GeneratedField::SortAgg),
5185 "rowSeqScan" | "row_seq_scan" => Ok(GeneratedField::RowSeqScan),
5186 "limit" => Ok(GeneratedField::Limit),
5187 "values" => Ok(GeneratedField::Values),
5188 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
5189 "mergeSortExchange" | "merge_sort_exchange" => Ok(GeneratedField::MergeSortExchange),
5190 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
5191 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
5192 "sysRowSeqScan" | "sys_row_seq_scan" => Ok(GeneratedField::SysRowSeqScan),
5193 "expand" => Ok(GeneratedField::Expand),
5194 "localLookupJoin" | "local_lookup_join" => Ok(GeneratedField::LocalLookupJoin),
5195 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
5196 "union" => Ok(GeneratedField::Union),
5197 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
5198 "distributedLookupJoin" | "distributed_lookup_join" => Ok(GeneratedField::DistributedLookupJoin),
5199 "source" => Ok(GeneratedField::Source),
5200 "sortOverWindow" | "sort_over_window" => Ok(GeneratedField::SortOverWindow),
5201 "maxOneRow" | "max_one_row" => Ok(GeneratedField::MaxOneRow),
5202 "logRowSeqScan" | "log_row_seq_scan" => Ok(GeneratedField::LogRowSeqScan),
5203 "fileScan" | "file_scan" => Ok(GeneratedField::FileScan),
5204 "icebergScan" | "iceberg_scan" => Ok(GeneratedField::IcebergScan),
5205 "postgresQuery" | "postgres_query" => Ok(GeneratedField::PostgresQuery),
5206 "mysqlQuery" | "mysql_query" => Ok(GeneratedField::MysqlQuery),
5207 "gcsFileScan" | "gcs_file_scan" => Ok(GeneratedField::GcsFileScan),
5208 "azblobFileScan" | "azblob_file_scan" => Ok(GeneratedField::AzblobFileScan),
5209 "blockExecutor" | "block_executor" => Ok(GeneratedField::BlockExecutor),
5210 "busyLoopExecutor" | "busy_loop_executor" => Ok(GeneratedField::BusyLoopExecutor),
5211 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5212 }
5213 }
5214 }
5215 deserializer.deserialize_identifier(GeneratedVisitor)
5216 }
5217 }
5218 struct GeneratedVisitor;
5219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5220 type Value = PlanNode;
5221
5222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5223 formatter.write_str("struct batch_plan.PlanNode")
5224 }
5225
5226 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanNode, V::Error>
5227 where
5228 V: serde::de::MapAccess<'de>,
5229 {
5230 let mut children__ = None;
5231 let mut identity__ = None;
5232 let mut node_body__ = None;
5233 while let Some(k) = map_.next_key()? {
5234 match k {
5235 GeneratedField::Children => {
5236 if children__.is_some() {
5237 return Err(serde::de::Error::duplicate_field("children"));
5238 }
5239 children__ = Some(map_.next_value()?);
5240 }
5241 GeneratedField::Identity => {
5242 if identity__.is_some() {
5243 return Err(serde::de::Error::duplicate_field("identity"));
5244 }
5245 identity__ = Some(map_.next_value()?);
5246 }
5247 GeneratedField::Insert => {
5248 if node_body__.is_some() {
5249 return Err(serde::de::Error::duplicate_field("insert"));
5250 }
5251 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Insert)
5252;
5253 }
5254 GeneratedField::Delete => {
5255 if node_body__.is_some() {
5256 return Err(serde::de::Error::duplicate_field("delete"));
5257 }
5258 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Delete)
5259;
5260 }
5261 GeneratedField::Update => {
5262 if node_body__.is_some() {
5263 return Err(serde::de::Error::duplicate_field("update"));
5264 }
5265 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Update)
5266;
5267 }
5268 GeneratedField::Project => {
5269 if node_body__.is_some() {
5270 return Err(serde::de::Error::duplicate_field("project"));
5271 }
5272 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Project)
5273;
5274 }
5275 GeneratedField::HashAgg => {
5276 if node_body__.is_some() {
5277 return Err(serde::de::Error::duplicate_field("hashAgg"));
5278 }
5279 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashAgg)
5280;
5281 }
5282 GeneratedField::Filter => {
5283 if node_body__.is_some() {
5284 return Err(serde::de::Error::duplicate_field("filter"));
5285 }
5286 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Filter)
5287;
5288 }
5289 GeneratedField::Exchange => {
5290 if node_body__.is_some() {
5291 return Err(serde::de::Error::duplicate_field("exchange"));
5292 }
5293 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Exchange)
5294;
5295 }
5296 GeneratedField::Sort => {
5297 if node_body__.is_some() {
5298 return Err(serde::de::Error::duplicate_field("sort"));
5299 }
5300 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Sort)
5301;
5302 }
5303 GeneratedField::NestedLoopJoin => {
5304 if node_body__.is_some() {
5305 return Err(serde::de::Error::duplicate_field("nestedLoopJoin"));
5306 }
5307 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::NestedLoopJoin)
5308;
5309 }
5310 GeneratedField::TopN => {
5311 if node_body__.is_some() {
5312 return Err(serde::de::Error::duplicate_field("topN"));
5313 }
5314 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TopN)
5315;
5316 }
5317 GeneratedField::SortAgg => {
5318 if node_body__.is_some() {
5319 return Err(serde::de::Error::duplicate_field("sortAgg"));
5320 }
5321 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortAgg)
5322;
5323 }
5324 GeneratedField::RowSeqScan => {
5325 if node_body__.is_some() {
5326 return Err(serde::de::Error::duplicate_field("rowSeqScan"));
5327 }
5328 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::RowSeqScan)
5329;
5330 }
5331 GeneratedField::Limit => {
5332 if node_body__.is_some() {
5333 return Err(serde::de::Error::duplicate_field("limit"));
5334 }
5335 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Limit)
5336;
5337 }
5338 GeneratedField::Values => {
5339 if node_body__.is_some() {
5340 return Err(serde::de::Error::duplicate_field("values"));
5341 }
5342 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Values)
5343;
5344 }
5345 GeneratedField::HashJoin => {
5346 if node_body__.is_some() {
5347 return Err(serde::de::Error::duplicate_field("hashJoin"));
5348 }
5349 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashJoin)
5350;
5351 }
5352 GeneratedField::MergeSortExchange => {
5353 if node_body__.is_some() {
5354 return Err(serde::de::Error::duplicate_field("mergeSortExchange"));
5355 }
5356 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MergeSortExchange)
5357;
5358 }
5359 GeneratedField::HopWindow => {
5360 if node_body__.is_some() {
5361 return Err(serde::de::Error::duplicate_field("hopWindow"));
5362 }
5363 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HopWindow)
5364;
5365 }
5366 GeneratedField::TableFunction => {
5367 if node_body__.is_some() {
5368 return Err(serde::de::Error::duplicate_field("tableFunction"));
5369 }
5370 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TableFunction)
5371;
5372 }
5373 GeneratedField::SysRowSeqScan => {
5374 if node_body__.is_some() {
5375 return Err(serde::de::Error::duplicate_field("sysRowSeqScan"));
5376 }
5377 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SysRowSeqScan)
5378;
5379 }
5380 GeneratedField::Expand => {
5381 if node_body__.is_some() {
5382 return Err(serde::de::Error::duplicate_field("expand"));
5383 }
5384 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Expand)
5385;
5386 }
5387 GeneratedField::LocalLookupJoin => {
5388 if node_body__.is_some() {
5389 return Err(serde::de::Error::duplicate_field("localLookupJoin"));
5390 }
5391 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LocalLookupJoin)
5392;
5393 }
5394 GeneratedField::ProjectSet => {
5395 if node_body__.is_some() {
5396 return Err(serde::de::Error::duplicate_field("projectSet"));
5397 }
5398 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::ProjectSet)
5399;
5400 }
5401 GeneratedField::Union => {
5402 if node_body__.is_some() {
5403 return Err(serde::de::Error::duplicate_field("union"));
5404 }
5405 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Union)
5406;
5407 }
5408 GeneratedField::GroupTopN => {
5409 if node_body__.is_some() {
5410 return Err(serde::de::Error::duplicate_field("groupTopN"));
5411 }
5412 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GroupTopN)
5413;
5414 }
5415 GeneratedField::DistributedLookupJoin => {
5416 if node_body__.is_some() {
5417 return Err(serde::de::Error::duplicate_field("distributedLookupJoin"));
5418 }
5419 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::DistributedLookupJoin)
5420;
5421 }
5422 GeneratedField::Source => {
5423 if node_body__.is_some() {
5424 return Err(serde::de::Error::duplicate_field("source"));
5425 }
5426 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Source)
5427;
5428 }
5429 GeneratedField::SortOverWindow => {
5430 if node_body__.is_some() {
5431 return Err(serde::de::Error::duplicate_field("sortOverWindow"));
5432 }
5433 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortOverWindow)
5434;
5435 }
5436 GeneratedField::MaxOneRow => {
5437 if node_body__.is_some() {
5438 return Err(serde::de::Error::duplicate_field("maxOneRow"));
5439 }
5440 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MaxOneRow)
5441;
5442 }
5443 GeneratedField::LogRowSeqScan => {
5444 if node_body__.is_some() {
5445 return Err(serde::de::Error::duplicate_field("logRowSeqScan"));
5446 }
5447 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LogRowSeqScan)
5448;
5449 }
5450 GeneratedField::FileScan => {
5451 if node_body__.is_some() {
5452 return Err(serde::de::Error::duplicate_field("fileScan"));
5453 }
5454 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::FileScan)
5455;
5456 }
5457 GeneratedField::IcebergScan => {
5458 if node_body__.is_some() {
5459 return Err(serde::de::Error::duplicate_field("icebergScan"));
5460 }
5461 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergScan)
5462;
5463 }
5464 GeneratedField::PostgresQuery => {
5465 if node_body__.is_some() {
5466 return Err(serde::de::Error::duplicate_field("postgresQuery"));
5467 }
5468 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::PostgresQuery)
5469;
5470 }
5471 GeneratedField::MysqlQuery => {
5472 if node_body__.is_some() {
5473 return Err(serde::de::Error::duplicate_field("mysqlQuery"));
5474 }
5475 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MysqlQuery)
5476;
5477 }
5478 GeneratedField::GcsFileScan => {
5479 if node_body__.is_some() {
5480 return Err(serde::de::Error::duplicate_field("gcsFileScan"));
5481 }
5482 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GcsFileScan)
5483;
5484 }
5485 GeneratedField::AzblobFileScan => {
5486 if node_body__.is_some() {
5487 return Err(serde::de::Error::duplicate_field("azblobFileScan"));
5488 }
5489 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::AzblobFileScan)
5490;
5491 }
5492 GeneratedField::BlockExecutor => {
5493 if node_body__.is_some() {
5494 return Err(serde::de::Error::duplicate_field("blockExecutor"));
5495 }
5496 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BlockExecutor);
5497 }
5498 GeneratedField::BusyLoopExecutor => {
5499 if node_body__.is_some() {
5500 return Err(serde::de::Error::duplicate_field("busyLoopExecutor"));
5501 }
5502 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BusyLoopExecutor);
5503 }
5504 }
5505 }
5506 Ok(PlanNode {
5507 children: children__.unwrap_or_default(),
5508 identity: identity__.unwrap_or_default(),
5509 node_body: node_body__,
5510 })
5511 }
5512 }
5513 deserializer.deserialize_struct("batch_plan.PlanNode", FIELDS, GeneratedVisitor)
5514 }
5515}
5516impl serde::Serialize for PostgresQueryNode {
5517 #[allow(deprecated)]
5518 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5519 where
5520 S: serde::Serializer,
5521 {
5522 use serde::ser::SerializeStruct;
5523 let mut len = 0;
5524 if !self.columns.is_empty() {
5525 len += 1;
5526 }
5527 if !self.hostname.is_empty() {
5528 len += 1;
5529 }
5530 if !self.port.is_empty() {
5531 len += 1;
5532 }
5533 if !self.username.is_empty() {
5534 len += 1;
5535 }
5536 if !self.password.is_empty() {
5537 len += 1;
5538 }
5539 if !self.database.is_empty() {
5540 len += 1;
5541 }
5542 if !self.query.is_empty() {
5543 len += 1;
5544 }
5545 let mut struct_ser = serializer.serialize_struct("batch_plan.PostgresQueryNode", len)?;
5546 if !self.columns.is_empty() {
5547 struct_ser.serialize_field("columns", &self.columns)?;
5548 }
5549 if !self.hostname.is_empty() {
5550 struct_ser.serialize_field("hostname", &self.hostname)?;
5551 }
5552 if !self.port.is_empty() {
5553 struct_ser.serialize_field("port", &self.port)?;
5554 }
5555 if !self.username.is_empty() {
5556 struct_ser.serialize_field("username", &self.username)?;
5557 }
5558 if !self.password.is_empty() {
5559 struct_ser.serialize_field("password", &self.password)?;
5560 }
5561 if !self.database.is_empty() {
5562 struct_ser.serialize_field("database", &self.database)?;
5563 }
5564 if !self.query.is_empty() {
5565 struct_ser.serialize_field("query", &self.query)?;
5566 }
5567 struct_ser.end()
5568 }
5569}
5570impl<'de> serde::Deserialize<'de> for PostgresQueryNode {
5571 #[allow(deprecated)]
5572 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5573 where
5574 D: serde::Deserializer<'de>,
5575 {
5576 const FIELDS: &[&str] = &[
5577 "columns",
5578 "hostname",
5579 "port",
5580 "username",
5581 "password",
5582 "database",
5583 "query",
5584 ];
5585
5586 #[allow(clippy::enum_variant_names)]
5587 enum GeneratedField {
5588 Columns,
5589 Hostname,
5590 Port,
5591 Username,
5592 Password,
5593 Database,
5594 Query,
5595 }
5596 impl<'de> serde::Deserialize<'de> for GeneratedField {
5597 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5598 where
5599 D: serde::Deserializer<'de>,
5600 {
5601 struct GeneratedVisitor;
5602
5603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5604 type Value = GeneratedField;
5605
5606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5607 write!(formatter, "expected one of: {:?}", &FIELDS)
5608 }
5609
5610 #[allow(unused_variables)]
5611 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5612 where
5613 E: serde::de::Error,
5614 {
5615 match value {
5616 "columns" => Ok(GeneratedField::Columns),
5617 "hostname" => Ok(GeneratedField::Hostname),
5618 "port" => Ok(GeneratedField::Port),
5619 "username" => Ok(GeneratedField::Username),
5620 "password" => Ok(GeneratedField::Password),
5621 "database" => Ok(GeneratedField::Database),
5622 "query" => Ok(GeneratedField::Query),
5623 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5624 }
5625 }
5626 }
5627 deserializer.deserialize_identifier(GeneratedVisitor)
5628 }
5629 }
5630 struct GeneratedVisitor;
5631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5632 type Value = PostgresQueryNode;
5633
5634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5635 formatter.write_str("struct batch_plan.PostgresQueryNode")
5636 }
5637
5638 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PostgresQueryNode, V::Error>
5639 where
5640 V: serde::de::MapAccess<'de>,
5641 {
5642 let mut columns__ = None;
5643 let mut hostname__ = None;
5644 let mut port__ = None;
5645 let mut username__ = None;
5646 let mut password__ = None;
5647 let mut database__ = None;
5648 let mut query__ = None;
5649 while let Some(k) = map_.next_key()? {
5650 match k {
5651 GeneratedField::Columns => {
5652 if columns__.is_some() {
5653 return Err(serde::de::Error::duplicate_field("columns"));
5654 }
5655 columns__ = Some(map_.next_value()?);
5656 }
5657 GeneratedField::Hostname => {
5658 if hostname__.is_some() {
5659 return Err(serde::de::Error::duplicate_field("hostname"));
5660 }
5661 hostname__ = Some(map_.next_value()?);
5662 }
5663 GeneratedField::Port => {
5664 if port__.is_some() {
5665 return Err(serde::de::Error::duplicate_field("port"));
5666 }
5667 port__ = Some(map_.next_value()?);
5668 }
5669 GeneratedField::Username => {
5670 if username__.is_some() {
5671 return Err(serde::de::Error::duplicate_field("username"));
5672 }
5673 username__ = Some(map_.next_value()?);
5674 }
5675 GeneratedField::Password => {
5676 if password__.is_some() {
5677 return Err(serde::de::Error::duplicate_field("password"));
5678 }
5679 password__ = Some(map_.next_value()?);
5680 }
5681 GeneratedField::Database => {
5682 if database__.is_some() {
5683 return Err(serde::de::Error::duplicate_field("database"));
5684 }
5685 database__ = Some(map_.next_value()?);
5686 }
5687 GeneratedField::Query => {
5688 if query__.is_some() {
5689 return Err(serde::de::Error::duplicate_field("query"));
5690 }
5691 query__ = Some(map_.next_value()?);
5692 }
5693 }
5694 }
5695 Ok(PostgresQueryNode {
5696 columns: columns__.unwrap_or_default(),
5697 hostname: hostname__.unwrap_or_default(),
5698 port: port__.unwrap_or_default(),
5699 username: username__.unwrap_or_default(),
5700 password: password__.unwrap_or_default(),
5701 database: database__.unwrap_or_default(),
5702 query: query__.unwrap_or_default(),
5703 })
5704 }
5705 }
5706 deserializer.deserialize_struct("batch_plan.PostgresQueryNode", FIELDS, GeneratedVisitor)
5707 }
5708}
5709impl serde::Serialize for ProjectNode {
5710 #[allow(deprecated)]
5711 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5712 where
5713 S: serde::Serializer,
5714 {
5715 use serde::ser::SerializeStruct;
5716 let mut len = 0;
5717 if !self.select_list.is_empty() {
5718 len += 1;
5719 }
5720 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectNode", len)?;
5721 if !self.select_list.is_empty() {
5722 struct_ser.serialize_field("selectList", &self.select_list)?;
5723 }
5724 struct_ser.end()
5725 }
5726}
5727impl<'de> serde::Deserialize<'de> for ProjectNode {
5728 #[allow(deprecated)]
5729 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5730 where
5731 D: serde::Deserializer<'de>,
5732 {
5733 const FIELDS: &[&str] = &[
5734 "select_list",
5735 "selectList",
5736 ];
5737
5738 #[allow(clippy::enum_variant_names)]
5739 enum GeneratedField {
5740 SelectList,
5741 }
5742 impl<'de> serde::Deserialize<'de> for GeneratedField {
5743 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5744 where
5745 D: serde::Deserializer<'de>,
5746 {
5747 struct GeneratedVisitor;
5748
5749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5750 type Value = GeneratedField;
5751
5752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5753 write!(formatter, "expected one of: {:?}", &FIELDS)
5754 }
5755
5756 #[allow(unused_variables)]
5757 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5758 where
5759 E: serde::de::Error,
5760 {
5761 match value {
5762 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5763 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5764 }
5765 }
5766 }
5767 deserializer.deserialize_identifier(GeneratedVisitor)
5768 }
5769 }
5770 struct GeneratedVisitor;
5771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5772 type Value = ProjectNode;
5773
5774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5775 formatter.write_str("struct batch_plan.ProjectNode")
5776 }
5777
5778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
5779 where
5780 V: serde::de::MapAccess<'de>,
5781 {
5782 let mut select_list__ = None;
5783 while let Some(k) = map_.next_key()? {
5784 match k {
5785 GeneratedField::SelectList => {
5786 if select_list__.is_some() {
5787 return Err(serde::de::Error::duplicate_field("selectList"));
5788 }
5789 select_list__ = Some(map_.next_value()?);
5790 }
5791 }
5792 }
5793 Ok(ProjectNode {
5794 select_list: select_list__.unwrap_or_default(),
5795 })
5796 }
5797 }
5798 deserializer.deserialize_struct("batch_plan.ProjectNode", FIELDS, GeneratedVisitor)
5799 }
5800}
5801impl serde::Serialize for ProjectSetNode {
5802 #[allow(deprecated)]
5803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5804 where
5805 S: serde::Serializer,
5806 {
5807 use serde::ser::SerializeStruct;
5808 let mut len = 0;
5809 if !self.select_list.is_empty() {
5810 len += 1;
5811 }
5812 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectSetNode", len)?;
5813 if !self.select_list.is_empty() {
5814 struct_ser.serialize_field("selectList", &self.select_list)?;
5815 }
5816 struct_ser.end()
5817 }
5818}
5819impl<'de> serde::Deserialize<'de> for ProjectSetNode {
5820 #[allow(deprecated)]
5821 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5822 where
5823 D: serde::Deserializer<'de>,
5824 {
5825 const FIELDS: &[&str] = &[
5826 "select_list",
5827 "selectList",
5828 ];
5829
5830 #[allow(clippy::enum_variant_names)]
5831 enum GeneratedField {
5832 SelectList,
5833 }
5834 impl<'de> serde::Deserialize<'de> for GeneratedField {
5835 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5836 where
5837 D: serde::Deserializer<'de>,
5838 {
5839 struct GeneratedVisitor;
5840
5841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5842 type Value = GeneratedField;
5843
5844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5845 write!(formatter, "expected one of: {:?}", &FIELDS)
5846 }
5847
5848 #[allow(unused_variables)]
5849 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5850 where
5851 E: serde::de::Error,
5852 {
5853 match value {
5854 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5855 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5856 }
5857 }
5858 }
5859 deserializer.deserialize_identifier(GeneratedVisitor)
5860 }
5861 }
5862 struct GeneratedVisitor;
5863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5864 type Value = ProjectSetNode;
5865
5866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5867 formatter.write_str("struct batch_plan.ProjectSetNode")
5868 }
5869
5870 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
5871 where
5872 V: serde::de::MapAccess<'de>,
5873 {
5874 let mut select_list__ = None;
5875 while let Some(k) = map_.next_key()? {
5876 match k {
5877 GeneratedField::SelectList => {
5878 if select_list__.is_some() {
5879 return Err(serde::de::Error::duplicate_field("selectList"));
5880 }
5881 select_list__ = Some(map_.next_value()?);
5882 }
5883 }
5884 }
5885 Ok(ProjectSetNode {
5886 select_list: select_list__.unwrap_or_default(),
5887 })
5888 }
5889 }
5890 deserializer.deserialize_struct("batch_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
5891 }
5892}
5893impl serde::Serialize for RowSeqScanNode {
5894 #[allow(deprecated)]
5895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5896 where
5897 S: serde::Serializer,
5898 {
5899 use serde::ser::SerializeStruct;
5900 let mut len = 0;
5901 if self.table_desc.is_some() {
5902 len += 1;
5903 }
5904 if !self.column_ids.is_empty() {
5905 len += 1;
5906 }
5907 if !self.scan_ranges.is_empty() {
5908 len += 1;
5909 }
5910 if self.vnode_bitmap.is_some() {
5911 len += 1;
5912 }
5913 if self.ordered {
5914 len += 1;
5915 }
5916 if self.limit.is_some() {
5917 len += 1;
5918 }
5919 if self.as_of.is_some() {
5920 len += 1;
5921 }
5922 let mut struct_ser = serializer.serialize_struct("batch_plan.RowSeqScanNode", len)?;
5923 if let Some(v) = self.table_desc.as_ref() {
5924 struct_ser.serialize_field("tableDesc", v)?;
5925 }
5926 if !self.column_ids.is_empty() {
5927 struct_ser.serialize_field("columnIds", &self.column_ids)?;
5928 }
5929 if !self.scan_ranges.is_empty() {
5930 struct_ser.serialize_field("scanRanges", &self.scan_ranges)?;
5931 }
5932 if let Some(v) = self.vnode_bitmap.as_ref() {
5933 struct_ser.serialize_field("vnodeBitmap", v)?;
5934 }
5935 if self.ordered {
5936 struct_ser.serialize_field("ordered", &self.ordered)?;
5937 }
5938 if let Some(v) = self.limit.as_ref() {
5939 #[allow(clippy::needless_borrow)]
5940 #[allow(clippy::needless_borrows_for_generic_args)]
5941 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
5942 }
5943 if let Some(v) = self.as_of.as_ref() {
5944 struct_ser.serialize_field("asOf", v)?;
5945 }
5946 struct_ser.end()
5947 }
5948}
5949impl<'de> serde::Deserialize<'de> for RowSeqScanNode {
5950 #[allow(deprecated)]
5951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5952 where
5953 D: serde::Deserializer<'de>,
5954 {
5955 const FIELDS: &[&str] = &[
5956 "table_desc",
5957 "tableDesc",
5958 "column_ids",
5959 "columnIds",
5960 "scan_ranges",
5961 "scanRanges",
5962 "vnode_bitmap",
5963 "vnodeBitmap",
5964 "ordered",
5965 "limit",
5966 "as_of",
5967 "asOf",
5968 ];
5969
5970 #[allow(clippy::enum_variant_names)]
5971 enum GeneratedField {
5972 TableDesc,
5973 ColumnIds,
5974 ScanRanges,
5975 VnodeBitmap,
5976 Ordered,
5977 Limit,
5978 AsOf,
5979 }
5980 impl<'de> serde::Deserialize<'de> for GeneratedField {
5981 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5982 where
5983 D: serde::Deserializer<'de>,
5984 {
5985 struct GeneratedVisitor;
5986
5987 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5988 type Value = GeneratedField;
5989
5990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5991 write!(formatter, "expected one of: {:?}", &FIELDS)
5992 }
5993
5994 #[allow(unused_variables)]
5995 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5996 where
5997 E: serde::de::Error,
5998 {
5999 match value {
6000 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
6001 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
6002 "scanRanges" | "scan_ranges" => Ok(GeneratedField::ScanRanges),
6003 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
6004 "ordered" => Ok(GeneratedField::Ordered),
6005 "limit" => Ok(GeneratedField::Limit),
6006 "asOf" | "as_of" => Ok(GeneratedField::AsOf),
6007 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6008 }
6009 }
6010 }
6011 deserializer.deserialize_identifier(GeneratedVisitor)
6012 }
6013 }
6014 struct GeneratedVisitor;
6015 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6016 type Value = RowSeqScanNode;
6017
6018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6019 formatter.write_str("struct batch_plan.RowSeqScanNode")
6020 }
6021
6022 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowSeqScanNode, V::Error>
6023 where
6024 V: serde::de::MapAccess<'de>,
6025 {
6026 let mut table_desc__ = None;
6027 let mut column_ids__ = None;
6028 let mut scan_ranges__ = None;
6029 let mut vnode_bitmap__ = None;
6030 let mut ordered__ = None;
6031 let mut limit__ = None;
6032 let mut as_of__ = None;
6033 while let Some(k) = map_.next_key()? {
6034 match k {
6035 GeneratedField::TableDesc => {
6036 if table_desc__.is_some() {
6037 return Err(serde::de::Error::duplicate_field("tableDesc"));
6038 }
6039 table_desc__ = map_.next_value()?;
6040 }
6041 GeneratedField::ColumnIds => {
6042 if column_ids__.is_some() {
6043 return Err(serde::de::Error::duplicate_field("columnIds"));
6044 }
6045 column_ids__ =
6046 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6047 .into_iter().map(|x| x.0).collect())
6048 ;
6049 }
6050 GeneratedField::ScanRanges => {
6051 if scan_ranges__.is_some() {
6052 return Err(serde::de::Error::duplicate_field("scanRanges"));
6053 }
6054 scan_ranges__ = Some(map_.next_value()?);
6055 }
6056 GeneratedField::VnodeBitmap => {
6057 if vnode_bitmap__.is_some() {
6058 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
6059 }
6060 vnode_bitmap__ = map_.next_value()?;
6061 }
6062 GeneratedField::Ordered => {
6063 if ordered__.is_some() {
6064 return Err(serde::de::Error::duplicate_field("ordered"));
6065 }
6066 ordered__ = Some(map_.next_value()?);
6067 }
6068 GeneratedField::Limit => {
6069 if limit__.is_some() {
6070 return Err(serde::de::Error::duplicate_field("limit"));
6071 }
6072 limit__ =
6073 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6074 ;
6075 }
6076 GeneratedField::AsOf => {
6077 if as_of__.is_some() {
6078 return Err(serde::de::Error::duplicate_field("asOf"));
6079 }
6080 as_of__ = map_.next_value()?;
6081 }
6082 }
6083 }
6084 Ok(RowSeqScanNode {
6085 table_desc: table_desc__,
6086 column_ids: column_ids__.unwrap_or_default(),
6087 scan_ranges: scan_ranges__.unwrap_or_default(),
6088 vnode_bitmap: vnode_bitmap__,
6089 ordered: ordered__.unwrap_or_default(),
6090 limit: limit__,
6091 as_of: as_of__,
6092 })
6093 }
6094 }
6095 deserializer.deserialize_struct("batch_plan.RowSeqScanNode", FIELDS, GeneratedVisitor)
6096 }
6097}
6098impl serde::Serialize for ScanRange {
6099 #[allow(deprecated)]
6100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6101 where
6102 S: serde::Serializer,
6103 {
6104 use serde::ser::SerializeStruct;
6105 let mut len = 0;
6106 if !self.eq_conds.is_empty() {
6107 len += 1;
6108 }
6109 if self.lower_bound.is_some() {
6110 len += 1;
6111 }
6112 if self.upper_bound.is_some() {
6113 len += 1;
6114 }
6115 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange", len)?;
6116 if !self.eq_conds.is_empty() {
6117 struct_ser.serialize_field("eqConds", &self.eq_conds.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6118 }
6119 if let Some(v) = self.lower_bound.as_ref() {
6120 struct_ser.serialize_field("lowerBound", v)?;
6121 }
6122 if let Some(v) = self.upper_bound.as_ref() {
6123 struct_ser.serialize_field("upperBound", v)?;
6124 }
6125 struct_ser.end()
6126 }
6127}
6128impl<'de> serde::Deserialize<'de> for ScanRange {
6129 #[allow(deprecated)]
6130 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6131 where
6132 D: serde::Deserializer<'de>,
6133 {
6134 const FIELDS: &[&str] = &[
6135 "eq_conds",
6136 "eqConds",
6137 "lower_bound",
6138 "lowerBound",
6139 "upper_bound",
6140 "upperBound",
6141 ];
6142
6143 #[allow(clippy::enum_variant_names)]
6144 enum GeneratedField {
6145 EqConds,
6146 LowerBound,
6147 UpperBound,
6148 }
6149 impl<'de> serde::Deserialize<'de> for GeneratedField {
6150 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6151 where
6152 D: serde::Deserializer<'de>,
6153 {
6154 struct GeneratedVisitor;
6155
6156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6157 type Value = GeneratedField;
6158
6159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6160 write!(formatter, "expected one of: {:?}", &FIELDS)
6161 }
6162
6163 #[allow(unused_variables)]
6164 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6165 where
6166 E: serde::de::Error,
6167 {
6168 match value {
6169 "eqConds" | "eq_conds" => Ok(GeneratedField::EqConds),
6170 "lowerBound" | "lower_bound" => Ok(GeneratedField::LowerBound),
6171 "upperBound" | "upper_bound" => Ok(GeneratedField::UpperBound),
6172 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6173 }
6174 }
6175 }
6176 deserializer.deserialize_identifier(GeneratedVisitor)
6177 }
6178 }
6179 struct GeneratedVisitor;
6180 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6181 type Value = ScanRange;
6182
6183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6184 formatter.write_str("struct batch_plan.ScanRange")
6185 }
6186
6187 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScanRange, V::Error>
6188 where
6189 V: serde::de::MapAccess<'de>,
6190 {
6191 let mut eq_conds__ = None;
6192 let mut lower_bound__ = None;
6193 let mut upper_bound__ = None;
6194 while let Some(k) = map_.next_key()? {
6195 match k {
6196 GeneratedField::EqConds => {
6197 if eq_conds__.is_some() {
6198 return Err(serde::de::Error::duplicate_field("eqConds"));
6199 }
6200 eq_conds__ =
6201 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6202 .into_iter().map(|x| x.0).collect())
6203 ;
6204 }
6205 GeneratedField::LowerBound => {
6206 if lower_bound__.is_some() {
6207 return Err(serde::de::Error::duplicate_field("lowerBound"));
6208 }
6209 lower_bound__ = map_.next_value()?;
6210 }
6211 GeneratedField::UpperBound => {
6212 if upper_bound__.is_some() {
6213 return Err(serde::de::Error::duplicate_field("upperBound"));
6214 }
6215 upper_bound__ = map_.next_value()?;
6216 }
6217 }
6218 }
6219 Ok(ScanRange {
6220 eq_conds: eq_conds__.unwrap_or_default(),
6221 lower_bound: lower_bound__,
6222 upper_bound: upper_bound__,
6223 })
6224 }
6225 }
6226 deserializer.deserialize_struct("batch_plan.ScanRange", FIELDS, GeneratedVisitor)
6227 }
6228}
6229impl serde::Serialize for scan_range::Bound {
6230 #[allow(deprecated)]
6231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6232 where
6233 S: serde::Serializer,
6234 {
6235 use serde::ser::SerializeStruct;
6236 let mut len = 0;
6237 if !self.value.is_empty() {
6238 len += 1;
6239 }
6240 if self.inclusive {
6241 len += 1;
6242 }
6243 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange.Bound", len)?;
6244 if !self.value.is_empty() {
6245 struct_ser.serialize_field("value", &self.value.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6246 }
6247 if self.inclusive {
6248 struct_ser.serialize_field("inclusive", &self.inclusive)?;
6249 }
6250 struct_ser.end()
6251 }
6252}
6253impl<'de> serde::Deserialize<'de> for scan_range::Bound {
6254 #[allow(deprecated)]
6255 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6256 where
6257 D: serde::Deserializer<'de>,
6258 {
6259 const FIELDS: &[&str] = &[
6260 "value",
6261 "inclusive",
6262 ];
6263
6264 #[allow(clippy::enum_variant_names)]
6265 enum GeneratedField {
6266 Value,
6267 Inclusive,
6268 }
6269 impl<'de> serde::Deserialize<'de> for GeneratedField {
6270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6271 where
6272 D: serde::Deserializer<'de>,
6273 {
6274 struct GeneratedVisitor;
6275
6276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6277 type Value = GeneratedField;
6278
6279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6280 write!(formatter, "expected one of: {:?}", &FIELDS)
6281 }
6282
6283 #[allow(unused_variables)]
6284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6285 where
6286 E: serde::de::Error,
6287 {
6288 match value {
6289 "value" => Ok(GeneratedField::Value),
6290 "inclusive" => Ok(GeneratedField::Inclusive),
6291 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6292 }
6293 }
6294 }
6295 deserializer.deserialize_identifier(GeneratedVisitor)
6296 }
6297 }
6298 struct GeneratedVisitor;
6299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6300 type Value = scan_range::Bound;
6301
6302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6303 formatter.write_str("struct batch_plan.ScanRange.Bound")
6304 }
6305
6306 fn visit_map<V>(self, mut map_: V) -> std::result::Result<scan_range::Bound, V::Error>
6307 where
6308 V: serde::de::MapAccess<'de>,
6309 {
6310 let mut value__ = None;
6311 let mut inclusive__ = None;
6312 while let Some(k) = map_.next_key()? {
6313 match k {
6314 GeneratedField::Value => {
6315 if value__.is_some() {
6316 return Err(serde::de::Error::duplicate_field("value"));
6317 }
6318 value__ =
6319 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6320 .into_iter().map(|x| x.0).collect())
6321 ;
6322 }
6323 GeneratedField::Inclusive => {
6324 if inclusive__.is_some() {
6325 return Err(serde::de::Error::duplicate_field("inclusive"));
6326 }
6327 inclusive__ = Some(map_.next_value()?);
6328 }
6329 }
6330 }
6331 Ok(scan_range::Bound {
6332 value: value__.unwrap_or_default(),
6333 inclusive: inclusive__.unwrap_or_default(),
6334 })
6335 }
6336 }
6337 deserializer.deserialize_struct("batch_plan.ScanRange.Bound", FIELDS, GeneratedVisitor)
6338 }
6339}
6340impl serde::Serialize for SortAggNode {
6341 #[allow(deprecated)]
6342 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6343 where
6344 S: serde::Serializer,
6345 {
6346 use serde::ser::SerializeStruct;
6347 let mut len = 0;
6348 if !self.group_key.is_empty() {
6349 len += 1;
6350 }
6351 if !self.agg_calls.is_empty() {
6352 len += 1;
6353 }
6354 let mut struct_ser = serializer.serialize_struct("batch_plan.SortAggNode", len)?;
6355 if !self.group_key.is_empty() {
6356 struct_ser.serialize_field("groupKey", &self.group_key)?;
6357 }
6358 if !self.agg_calls.is_empty() {
6359 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6360 }
6361 struct_ser.end()
6362 }
6363}
6364impl<'de> serde::Deserialize<'de> for SortAggNode {
6365 #[allow(deprecated)]
6366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6367 where
6368 D: serde::Deserializer<'de>,
6369 {
6370 const FIELDS: &[&str] = &[
6371 "group_key",
6372 "groupKey",
6373 "agg_calls",
6374 "aggCalls",
6375 ];
6376
6377 #[allow(clippy::enum_variant_names)]
6378 enum GeneratedField {
6379 GroupKey,
6380 AggCalls,
6381 }
6382 impl<'de> serde::Deserialize<'de> for GeneratedField {
6383 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6384 where
6385 D: serde::Deserializer<'de>,
6386 {
6387 struct GeneratedVisitor;
6388
6389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6390 type Value = GeneratedField;
6391
6392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6393 write!(formatter, "expected one of: {:?}", &FIELDS)
6394 }
6395
6396 #[allow(unused_variables)]
6397 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6398 where
6399 E: serde::de::Error,
6400 {
6401 match value {
6402 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6403 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6404 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6405 }
6406 }
6407 }
6408 deserializer.deserialize_identifier(GeneratedVisitor)
6409 }
6410 }
6411 struct GeneratedVisitor;
6412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6413 type Value = SortAggNode;
6414
6415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6416 formatter.write_str("struct batch_plan.SortAggNode")
6417 }
6418
6419 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortAggNode, V::Error>
6420 where
6421 V: serde::de::MapAccess<'de>,
6422 {
6423 let mut group_key__ = None;
6424 let mut agg_calls__ = None;
6425 while let Some(k) = map_.next_key()? {
6426 match k {
6427 GeneratedField::GroupKey => {
6428 if group_key__.is_some() {
6429 return Err(serde::de::Error::duplicate_field("groupKey"));
6430 }
6431 group_key__ = Some(map_.next_value()?);
6432 }
6433 GeneratedField::AggCalls => {
6434 if agg_calls__.is_some() {
6435 return Err(serde::de::Error::duplicate_field("aggCalls"));
6436 }
6437 agg_calls__ = Some(map_.next_value()?);
6438 }
6439 }
6440 }
6441 Ok(SortAggNode {
6442 group_key: group_key__.unwrap_or_default(),
6443 agg_calls: agg_calls__.unwrap_or_default(),
6444 })
6445 }
6446 }
6447 deserializer.deserialize_struct("batch_plan.SortAggNode", FIELDS, GeneratedVisitor)
6448 }
6449}
6450impl serde::Serialize for SortMergeJoinNode {
6451 #[allow(deprecated)]
6452 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6453 where
6454 S: serde::Serializer,
6455 {
6456 use serde::ser::SerializeStruct;
6457 let mut len = 0;
6458 if self.join_type != 0 {
6459 len += 1;
6460 }
6461 if !self.left_key.is_empty() {
6462 len += 1;
6463 }
6464 if !self.right_key.is_empty() {
6465 len += 1;
6466 }
6467 if self.direction != 0 {
6468 len += 1;
6469 }
6470 if !self.output_indices.is_empty() {
6471 len += 1;
6472 }
6473 let mut struct_ser = serializer.serialize_struct("batch_plan.SortMergeJoinNode", len)?;
6474 if self.join_type != 0 {
6475 let v = super::plan_common::JoinType::try_from(self.join_type)
6476 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6477 struct_ser.serialize_field("joinType", &v)?;
6478 }
6479 if !self.left_key.is_empty() {
6480 struct_ser.serialize_field("leftKey", &self.left_key)?;
6481 }
6482 if !self.right_key.is_empty() {
6483 struct_ser.serialize_field("rightKey", &self.right_key)?;
6484 }
6485 if self.direction != 0 {
6486 let v = super::common::Direction::try_from(self.direction)
6487 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
6488 struct_ser.serialize_field("direction", &v)?;
6489 }
6490 if !self.output_indices.is_empty() {
6491 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6492 }
6493 struct_ser.end()
6494 }
6495}
6496impl<'de> serde::Deserialize<'de> for SortMergeJoinNode {
6497 #[allow(deprecated)]
6498 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6499 where
6500 D: serde::Deserializer<'de>,
6501 {
6502 const FIELDS: &[&str] = &[
6503 "join_type",
6504 "joinType",
6505 "left_key",
6506 "leftKey",
6507 "right_key",
6508 "rightKey",
6509 "direction",
6510 "output_indices",
6511 "outputIndices",
6512 ];
6513
6514 #[allow(clippy::enum_variant_names)]
6515 enum GeneratedField {
6516 JoinType,
6517 LeftKey,
6518 RightKey,
6519 Direction,
6520 OutputIndices,
6521 }
6522 impl<'de> serde::Deserialize<'de> for GeneratedField {
6523 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6524 where
6525 D: serde::Deserializer<'de>,
6526 {
6527 struct GeneratedVisitor;
6528
6529 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6530 type Value = GeneratedField;
6531
6532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6533 write!(formatter, "expected one of: {:?}", &FIELDS)
6534 }
6535
6536 #[allow(unused_variables)]
6537 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6538 where
6539 E: serde::de::Error,
6540 {
6541 match value {
6542 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6543 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6544 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6545 "direction" => Ok(GeneratedField::Direction),
6546 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6547 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6548 }
6549 }
6550 }
6551 deserializer.deserialize_identifier(GeneratedVisitor)
6552 }
6553 }
6554 struct GeneratedVisitor;
6555 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6556 type Value = SortMergeJoinNode;
6557
6558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6559 formatter.write_str("struct batch_plan.SortMergeJoinNode")
6560 }
6561
6562 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortMergeJoinNode, V::Error>
6563 where
6564 V: serde::de::MapAccess<'de>,
6565 {
6566 let mut join_type__ = None;
6567 let mut left_key__ = None;
6568 let mut right_key__ = None;
6569 let mut direction__ = None;
6570 let mut output_indices__ = None;
6571 while let Some(k) = map_.next_key()? {
6572 match k {
6573 GeneratedField::JoinType => {
6574 if join_type__.is_some() {
6575 return Err(serde::de::Error::duplicate_field("joinType"));
6576 }
6577 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6578 }
6579 GeneratedField::LeftKey => {
6580 if left_key__.is_some() {
6581 return Err(serde::de::Error::duplicate_field("leftKey"));
6582 }
6583 left_key__ =
6584 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6585 .into_iter().map(|x| x.0).collect())
6586 ;
6587 }
6588 GeneratedField::RightKey => {
6589 if right_key__.is_some() {
6590 return Err(serde::de::Error::duplicate_field("rightKey"));
6591 }
6592 right_key__ =
6593 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6594 .into_iter().map(|x| x.0).collect())
6595 ;
6596 }
6597 GeneratedField::Direction => {
6598 if direction__.is_some() {
6599 return Err(serde::de::Error::duplicate_field("direction"));
6600 }
6601 direction__ = Some(map_.next_value::<super::common::Direction>()? as i32);
6602 }
6603 GeneratedField::OutputIndices => {
6604 if output_indices__.is_some() {
6605 return Err(serde::de::Error::duplicate_field("outputIndices"));
6606 }
6607 output_indices__ =
6608 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6609 .into_iter().map(|x| x.0).collect())
6610 ;
6611 }
6612 }
6613 }
6614 Ok(SortMergeJoinNode {
6615 join_type: join_type__.unwrap_or_default(),
6616 left_key: left_key__.unwrap_or_default(),
6617 right_key: right_key__.unwrap_or_default(),
6618 direction: direction__.unwrap_or_default(),
6619 output_indices: output_indices__.unwrap_or_default(),
6620 })
6621 }
6622 }
6623 deserializer.deserialize_struct("batch_plan.SortMergeJoinNode", FIELDS, GeneratedVisitor)
6624 }
6625}
6626impl serde::Serialize for SortNode {
6627 #[allow(deprecated)]
6628 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6629 where
6630 S: serde::Serializer,
6631 {
6632 use serde::ser::SerializeStruct;
6633 let mut len = 0;
6634 if !self.column_orders.is_empty() {
6635 len += 1;
6636 }
6637 let mut struct_ser = serializer.serialize_struct("batch_plan.SortNode", len)?;
6638 if !self.column_orders.is_empty() {
6639 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6640 }
6641 struct_ser.end()
6642 }
6643}
6644impl<'de> serde::Deserialize<'de> for SortNode {
6645 #[allow(deprecated)]
6646 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6647 where
6648 D: serde::Deserializer<'de>,
6649 {
6650 const FIELDS: &[&str] = &[
6651 "column_orders",
6652 "columnOrders",
6653 ];
6654
6655 #[allow(clippy::enum_variant_names)]
6656 enum GeneratedField {
6657 ColumnOrders,
6658 }
6659 impl<'de> serde::Deserialize<'de> for GeneratedField {
6660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6661 where
6662 D: serde::Deserializer<'de>,
6663 {
6664 struct GeneratedVisitor;
6665
6666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6667 type Value = GeneratedField;
6668
6669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6670 write!(formatter, "expected one of: {:?}", &FIELDS)
6671 }
6672
6673 #[allow(unused_variables)]
6674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6675 where
6676 E: serde::de::Error,
6677 {
6678 match value {
6679 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6680 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6681 }
6682 }
6683 }
6684 deserializer.deserialize_identifier(GeneratedVisitor)
6685 }
6686 }
6687 struct GeneratedVisitor;
6688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6689 type Value = SortNode;
6690
6691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6692 formatter.write_str("struct batch_plan.SortNode")
6693 }
6694
6695 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
6696 where
6697 V: serde::de::MapAccess<'de>,
6698 {
6699 let mut column_orders__ = None;
6700 while let Some(k) = map_.next_key()? {
6701 match k {
6702 GeneratedField::ColumnOrders => {
6703 if column_orders__.is_some() {
6704 return Err(serde::de::Error::duplicate_field("columnOrders"));
6705 }
6706 column_orders__ = Some(map_.next_value()?);
6707 }
6708 }
6709 }
6710 Ok(SortNode {
6711 column_orders: column_orders__.unwrap_or_default(),
6712 })
6713 }
6714 }
6715 deserializer.deserialize_struct("batch_plan.SortNode", FIELDS, GeneratedVisitor)
6716 }
6717}
6718impl serde::Serialize for SortOverWindowNode {
6719 #[allow(deprecated)]
6720 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6721 where
6722 S: serde::Serializer,
6723 {
6724 use serde::ser::SerializeStruct;
6725 let mut len = 0;
6726 if !self.calls.is_empty() {
6727 len += 1;
6728 }
6729 if !self.partition_by.is_empty() {
6730 len += 1;
6731 }
6732 if !self.order_by.is_empty() {
6733 len += 1;
6734 }
6735 let mut struct_ser = serializer.serialize_struct("batch_plan.SortOverWindowNode", len)?;
6736 if !self.calls.is_empty() {
6737 struct_ser.serialize_field("calls", &self.calls)?;
6738 }
6739 if !self.partition_by.is_empty() {
6740 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
6741 }
6742 if !self.order_by.is_empty() {
6743 struct_ser.serialize_field("orderBy", &self.order_by)?;
6744 }
6745 struct_ser.end()
6746 }
6747}
6748impl<'de> serde::Deserialize<'de> for SortOverWindowNode {
6749 #[allow(deprecated)]
6750 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6751 where
6752 D: serde::Deserializer<'de>,
6753 {
6754 const FIELDS: &[&str] = &[
6755 "calls",
6756 "partition_by",
6757 "partitionBy",
6758 "order_by",
6759 "orderBy",
6760 ];
6761
6762 #[allow(clippy::enum_variant_names)]
6763 enum GeneratedField {
6764 Calls,
6765 PartitionBy,
6766 OrderBy,
6767 }
6768 impl<'de> serde::Deserialize<'de> for GeneratedField {
6769 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6770 where
6771 D: serde::Deserializer<'de>,
6772 {
6773 struct GeneratedVisitor;
6774
6775 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6776 type Value = GeneratedField;
6777
6778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6779 write!(formatter, "expected one of: {:?}", &FIELDS)
6780 }
6781
6782 #[allow(unused_variables)]
6783 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6784 where
6785 E: serde::de::Error,
6786 {
6787 match value {
6788 "calls" => Ok(GeneratedField::Calls),
6789 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
6790 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
6791 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6792 }
6793 }
6794 }
6795 deserializer.deserialize_identifier(GeneratedVisitor)
6796 }
6797 }
6798 struct GeneratedVisitor;
6799 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6800 type Value = SortOverWindowNode;
6801
6802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6803 formatter.write_str("struct batch_plan.SortOverWindowNode")
6804 }
6805
6806 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortOverWindowNode, V::Error>
6807 where
6808 V: serde::de::MapAccess<'de>,
6809 {
6810 let mut calls__ = None;
6811 let mut partition_by__ = None;
6812 let mut order_by__ = None;
6813 while let Some(k) = map_.next_key()? {
6814 match k {
6815 GeneratedField::Calls => {
6816 if calls__.is_some() {
6817 return Err(serde::de::Error::duplicate_field("calls"));
6818 }
6819 calls__ = Some(map_.next_value()?);
6820 }
6821 GeneratedField::PartitionBy => {
6822 if partition_by__.is_some() {
6823 return Err(serde::de::Error::duplicate_field("partitionBy"));
6824 }
6825 partition_by__ =
6826 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6827 .into_iter().map(|x| x.0).collect())
6828 ;
6829 }
6830 GeneratedField::OrderBy => {
6831 if order_by__.is_some() {
6832 return Err(serde::de::Error::duplicate_field("orderBy"));
6833 }
6834 order_by__ = Some(map_.next_value()?);
6835 }
6836 }
6837 }
6838 Ok(SortOverWindowNode {
6839 calls: calls__.unwrap_or_default(),
6840 partition_by: partition_by__.unwrap_or_default(),
6841 order_by: order_by__.unwrap_or_default(),
6842 })
6843 }
6844 }
6845 deserializer.deserialize_struct("batch_plan.SortOverWindowNode", FIELDS, GeneratedVisitor)
6846 }
6847}
6848impl serde::Serialize for SourceNode {
6849 #[allow(deprecated)]
6850 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6851 where
6852 S: serde::Serializer,
6853 {
6854 use serde::ser::SerializeStruct;
6855 let mut len = 0;
6856 if self.source_id != 0 {
6857 len += 1;
6858 }
6859 if !self.columns.is_empty() {
6860 len += 1;
6861 }
6862 if !self.with_properties.is_empty() {
6863 len += 1;
6864 }
6865 if !self.split.is_empty() {
6866 len += 1;
6867 }
6868 if self.info.is_some() {
6869 len += 1;
6870 }
6871 if !self.secret_refs.is_empty() {
6872 len += 1;
6873 }
6874 let mut struct_ser = serializer.serialize_struct("batch_plan.SourceNode", len)?;
6875 if self.source_id != 0 {
6876 struct_ser.serialize_field("sourceId", &self.source_id)?;
6877 }
6878 if !self.columns.is_empty() {
6879 struct_ser.serialize_field("columns", &self.columns)?;
6880 }
6881 if !self.with_properties.is_empty() {
6882 struct_ser.serialize_field("withProperties", &self.with_properties)?;
6883 }
6884 if !self.split.is_empty() {
6885 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6886 }
6887 if let Some(v) = self.info.as_ref() {
6888 struct_ser.serialize_field("info", v)?;
6889 }
6890 if !self.secret_refs.is_empty() {
6891 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
6892 }
6893 struct_ser.end()
6894 }
6895}
6896impl<'de> serde::Deserialize<'de> for SourceNode {
6897 #[allow(deprecated)]
6898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6899 where
6900 D: serde::Deserializer<'de>,
6901 {
6902 const FIELDS: &[&str] = &[
6903 "source_id",
6904 "sourceId",
6905 "columns",
6906 "with_properties",
6907 "withProperties",
6908 "split",
6909 "info",
6910 "secret_refs",
6911 "secretRefs",
6912 ];
6913
6914 #[allow(clippy::enum_variant_names)]
6915 enum GeneratedField {
6916 SourceId,
6917 Columns,
6918 WithProperties,
6919 Split,
6920 Info,
6921 SecretRefs,
6922 }
6923 impl<'de> serde::Deserialize<'de> for GeneratedField {
6924 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6925 where
6926 D: serde::Deserializer<'de>,
6927 {
6928 struct GeneratedVisitor;
6929
6930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6931 type Value = GeneratedField;
6932
6933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6934 write!(formatter, "expected one of: {:?}", &FIELDS)
6935 }
6936
6937 #[allow(unused_variables)]
6938 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6939 where
6940 E: serde::de::Error,
6941 {
6942 match value {
6943 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
6944 "columns" => Ok(GeneratedField::Columns),
6945 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
6946 "split" => Ok(GeneratedField::Split),
6947 "info" => Ok(GeneratedField::Info),
6948 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
6949 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6950 }
6951 }
6952 }
6953 deserializer.deserialize_identifier(GeneratedVisitor)
6954 }
6955 }
6956 struct GeneratedVisitor;
6957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6958 type Value = SourceNode;
6959
6960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6961 formatter.write_str("struct batch_plan.SourceNode")
6962 }
6963
6964 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
6965 where
6966 V: serde::de::MapAccess<'de>,
6967 {
6968 let mut source_id__ = None;
6969 let mut columns__ = None;
6970 let mut with_properties__ = None;
6971 let mut split__ = None;
6972 let mut info__ = None;
6973 let mut secret_refs__ = None;
6974 while let Some(k) = map_.next_key()? {
6975 match k {
6976 GeneratedField::SourceId => {
6977 if source_id__.is_some() {
6978 return Err(serde::de::Error::duplicate_field("sourceId"));
6979 }
6980 source_id__ =
6981 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6982 ;
6983 }
6984 GeneratedField::Columns => {
6985 if columns__.is_some() {
6986 return Err(serde::de::Error::duplicate_field("columns"));
6987 }
6988 columns__ = Some(map_.next_value()?);
6989 }
6990 GeneratedField::WithProperties => {
6991 if with_properties__.is_some() {
6992 return Err(serde::de::Error::duplicate_field("withProperties"));
6993 }
6994 with_properties__ = Some(
6995 map_.next_value::<std::collections::BTreeMap<_, _>>()?
6996 );
6997 }
6998 GeneratedField::Split => {
6999 if split__.is_some() {
7000 return Err(serde::de::Error::duplicate_field("split"));
7001 }
7002 split__ =
7003 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7004 .into_iter().map(|x| x.0).collect())
7005 ;
7006 }
7007 GeneratedField::Info => {
7008 if info__.is_some() {
7009 return Err(serde::de::Error::duplicate_field("info"));
7010 }
7011 info__ = map_.next_value()?;
7012 }
7013 GeneratedField::SecretRefs => {
7014 if secret_refs__.is_some() {
7015 return Err(serde::de::Error::duplicate_field("secretRefs"));
7016 }
7017 secret_refs__ = Some(
7018 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7019 );
7020 }
7021 }
7022 }
7023 Ok(SourceNode {
7024 source_id: source_id__.unwrap_or_default(),
7025 columns: columns__.unwrap_or_default(),
7026 with_properties: with_properties__.unwrap_or_default(),
7027 split: split__.unwrap_or_default(),
7028 info: info__,
7029 secret_refs: secret_refs__.unwrap_or_default(),
7030 })
7031 }
7032 }
7033 deserializer.deserialize_struct("batch_plan.SourceNode", FIELDS, GeneratedVisitor)
7034 }
7035}
7036impl serde::Serialize for SysRowSeqScanNode {
7037 #[allow(deprecated)]
7038 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7039 where
7040 S: serde::Serializer,
7041 {
7042 use serde::ser::SerializeStruct;
7043 let mut len = 0;
7044 if self.table_id != 0 {
7045 len += 1;
7046 }
7047 if !self.column_descs.is_empty() {
7048 len += 1;
7049 }
7050 let mut struct_ser = serializer.serialize_struct("batch_plan.SysRowSeqScanNode", len)?;
7051 if self.table_id != 0 {
7052 struct_ser.serialize_field("tableId", &self.table_id)?;
7053 }
7054 if !self.column_descs.is_empty() {
7055 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
7056 }
7057 struct_ser.end()
7058 }
7059}
7060impl<'de> serde::Deserialize<'de> for SysRowSeqScanNode {
7061 #[allow(deprecated)]
7062 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7063 where
7064 D: serde::Deserializer<'de>,
7065 {
7066 const FIELDS: &[&str] = &[
7067 "table_id",
7068 "tableId",
7069 "column_descs",
7070 "columnDescs",
7071 ];
7072
7073 #[allow(clippy::enum_variant_names)]
7074 enum GeneratedField {
7075 TableId,
7076 ColumnDescs,
7077 }
7078 impl<'de> serde::Deserialize<'de> for GeneratedField {
7079 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7080 where
7081 D: serde::Deserializer<'de>,
7082 {
7083 struct GeneratedVisitor;
7084
7085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7086 type Value = GeneratedField;
7087
7088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7089 write!(formatter, "expected one of: {:?}", &FIELDS)
7090 }
7091
7092 #[allow(unused_variables)]
7093 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7094 where
7095 E: serde::de::Error,
7096 {
7097 match value {
7098 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7099 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
7100 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7101 }
7102 }
7103 }
7104 deserializer.deserialize_identifier(GeneratedVisitor)
7105 }
7106 }
7107 struct GeneratedVisitor;
7108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7109 type Value = SysRowSeqScanNode;
7110
7111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7112 formatter.write_str("struct batch_plan.SysRowSeqScanNode")
7113 }
7114
7115 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SysRowSeqScanNode, V::Error>
7116 where
7117 V: serde::de::MapAccess<'de>,
7118 {
7119 let mut table_id__ = None;
7120 let mut column_descs__ = None;
7121 while let Some(k) = map_.next_key()? {
7122 match k {
7123 GeneratedField::TableId => {
7124 if table_id__.is_some() {
7125 return Err(serde::de::Error::duplicate_field("tableId"));
7126 }
7127 table_id__ =
7128 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7129 ;
7130 }
7131 GeneratedField::ColumnDescs => {
7132 if column_descs__.is_some() {
7133 return Err(serde::de::Error::duplicate_field("columnDescs"));
7134 }
7135 column_descs__ = Some(map_.next_value()?);
7136 }
7137 }
7138 }
7139 Ok(SysRowSeqScanNode {
7140 table_id: table_id__.unwrap_or_default(),
7141 column_descs: column_descs__.unwrap_or_default(),
7142 })
7143 }
7144 }
7145 deserializer.deserialize_struct("batch_plan.SysRowSeqScanNode", FIELDS, GeneratedVisitor)
7146 }
7147}
7148impl serde::Serialize for TableFunctionNode {
7149 #[allow(deprecated)]
7150 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7151 where
7152 S: serde::Serializer,
7153 {
7154 use serde::ser::SerializeStruct;
7155 let mut len = 0;
7156 if self.table_function.is_some() {
7157 len += 1;
7158 }
7159 let mut struct_ser = serializer.serialize_struct("batch_plan.TableFunctionNode", len)?;
7160 if let Some(v) = self.table_function.as_ref() {
7161 struct_ser.serialize_field("tableFunction", v)?;
7162 }
7163 struct_ser.end()
7164 }
7165}
7166impl<'de> serde::Deserialize<'de> for TableFunctionNode {
7167 #[allow(deprecated)]
7168 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7169 where
7170 D: serde::Deserializer<'de>,
7171 {
7172 const FIELDS: &[&str] = &[
7173 "table_function",
7174 "tableFunction",
7175 ];
7176
7177 #[allow(clippy::enum_variant_names)]
7178 enum GeneratedField {
7179 TableFunction,
7180 }
7181 impl<'de> serde::Deserialize<'de> for GeneratedField {
7182 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7183 where
7184 D: serde::Deserializer<'de>,
7185 {
7186 struct GeneratedVisitor;
7187
7188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7189 type Value = GeneratedField;
7190
7191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7192 write!(formatter, "expected one of: {:?}", &FIELDS)
7193 }
7194
7195 #[allow(unused_variables)]
7196 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7197 where
7198 E: serde::de::Error,
7199 {
7200 match value {
7201 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
7202 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7203 }
7204 }
7205 }
7206 deserializer.deserialize_identifier(GeneratedVisitor)
7207 }
7208 }
7209 struct GeneratedVisitor;
7210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7211 type Value = TableFunctionNode;
7212
7213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7214 formatter.write_str("struct batch_plan.TableFunctionNode")
7215 }
7216
7217 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunctionNode, V::Error>
7218 where
7219 V: serde::de::MapAccess<'de>,
7220 {
7221 let mut table_function__ = None;
7222 while let Some(k) = map_.next_key()? {
7223 match k {
7224 GeneratedField::TableFunction => {
7225 if table_function__.is_some() {
7226 return Err(serde::de::Error::duplicate_field("tableFunction"));
7227 }
7228 table_function__ = map_.next_value()?;
7229 }
7230 }
7231 }
7232 Ok(TableFunctionNode {
7233 table_function: table_function__,
7234 })
7235 }
7236 }
7237 deserializer.deserialize_struct("batch_plan.TableFunctionNode", FIELDS, GeneratedVisitor)
7238 }
7239}
7240impl serde::Serialize for TaskId {
7241 #[allow(deprecated)]
7242 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7243 where
7244 S: serde::Serializer,
7245 {
7246 use serde::ser::SerializeStruct;
7247 let mut len = 0;
7248 if !self.query_id.is_empty() {
7249 len += 1;
7250 }
7251 if self.stage_id != 0 {
7252 len += 1;
7253 }
7254 if self.task_id != 0 {
7255 len += 1;
7256 }
7257 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskId", len)?;
7258 if !self.query_id.is_empty() {
7259 struct_ser.serialize_field("queryId", &self.query_id)?;
7260 }
7261 if self.stage_id != 0 {
7262 struct_ser.serialize_field("stageId", &self.stage_id)?;
7263 }
7264 if self.task_id != 0 {
7265 #[allow(clippy::needless_borrow)]
7266 #[allow(clippy::needless_borrows_for_generic_args)]
7267 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7268 }
7269 struct_ser.end()
7270 }
7271}
7272impl<'de> serde::Deserialize<'de> for TaskId {
7273 #[allow(deprecated)]
7274 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7275 where
7276 D: serde::Deserializer<'de>,
7277 {
7278 const FIELDS: &[&str] = &[
7279 "query_id",
7280 "queryId",
7281 "stage_id",
7282 "stageId",
7283 "task_id",
7284 "taskId",
7285 ];
7286
7287 #[allow(clippy::enum_variant_names)]
7288 enum GeneratedField {
7289 QueryId,
7290 StageId,
7291 TaskId,
7292 }
7293 impl<'de> serde::Deserialize<'de> for GeneratedField {
7294 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7295 where
7296 D: serde::Deserializer<'de>,
7297 {
7298 struct GeneratedVisitor;
7299
7300 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7301 type Value = GeneratedField;
7302
7303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7304 write!(formatter, "expected one of: {:?}", &FIELDS)
7305 }
7306
7307 #[allow(unused_variables)]
7308 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7309 where
7310 E: serde::de::Error,
7311 {
7312 match value {
7313 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
7314 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
7315 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7316 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7317 }
7318 }
7319 }
7320 deserializer.deserialize_identifier(GeneratedVisitor)
7321 }
7322 }
7323 struct GeneratedVisitor;
7324 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7325 type Value = TaskId;
7326
7327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7328 formatter.write_str("struct batch_plan.TaskId")
7329 }
7330
7331 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
7332 where
7333 V: serde::de::MapAccess<'de>,
7334 {
7335 let mut query_id__ = None;
7336 let mut stage_id__ = None;
7337 let mut task_id__ = None;
7338 while let Some(k) = map_.next_key()? {
7339 match k {
7340 GeneratedField::QueryId => {
7341 if query_id__.is_some() {
7342 return Err(serde::de::Error::duplicate_field("queryId"));
7343 }
7344 query_id__ = Some(map_.next_value()?);
7345 }
7346 GeneratedField::StageId => {
7347 if stage_id__.is_some() {
7348 return Err(serde::de::Error::duplicate_field("stageId"));
7349 }
7350 stage_id__ =
7351 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7352 ;
7353 }
7354 GeneratedField::TaskId => {
7355 if task_id__.is_some() {
7356 return Err(serde::de::Error::duplicate_field("taskId"));
7357 }
7358 task_id__ =
7359 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7360 ;
7361 }
7362 }
7363 }
7364 Ok(TaskId {
7365 query_id: query_id__.unwrap_or_default(),
7366 stage_id: stage_id__.unwrap_or_default(),
7367 task_id: task_id__.unwrap_or_default(),
7368 })
7369 }
7370 }
7371 deserializer.deserialize_struct("batch_plan.TaskId", FIELDS, GeneratedVisitor)
7372 }
7373}
7374impl serde::Serialize for TaskOutputId {
7375 #[allow(deprecated)]
7376 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7377 where
7378 S: serde::Serializer,
7379 {
7380 use serde::ser::SerializeStruct;
7381 let mut len = 0;
7382 if self.task_id.is_some() {
7383 len += 1;
7384 }
7385 if self.output_id != 0 {
7386 len += 1;
7387 }
7388 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskOutputId", len)?;
7389 if let Some(v) = self.task_id.as_ref() {
7390 struct_ser.serialize_field("taskId", v)?;
7391 }
7392 if self.output_id != 0 {
7393 #[allow(clippy::needless_borrow)]
7394 #[allow(clippy::needless_borrows_for_generic_args)]
7395 struct_ser.serialize_field("outputId", ToString::to_string(&self.output_id).as_str())?;
7396 }
7397 struct_ser.end()
7398 }
7399}
7400impl<'de> serde::Deserialize<'de> for TaskOutputId {
7401 #[allow(deprecated)]
7402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7403 where
7404 D: serde::Deserializer<'de>,
7405 {
7406 const FIELDS: &[&str] = &[
7407 "task_id",
7408 "taskId",
7409 "output_id",
7410 "outputId",
7411 ];
7412
7413 #[allow(clippy::enum_variant_names)]
7414 enum GeneratedField {
7415 TaskId,
7416 OutputId,
7417 }
7418 impl<'de> serde::Deserialize<'de> for GeneratedField {
7419 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7420 where
7421 D: serde::Deserializer<'de>,
7422 {
7423 struct GeneratedVisitor;
7424
7425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7426 type Value = GeneratedField;
7427
7428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7429 write!(formatter, "expected one of: {:?}", &FIELDS)
7430 }
7431
7432 #[allow(unused_variables)]
7433 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7434 where
7435 E: serde::de::Error,
7436 {
7437 match value {
7438 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7439 "outputId" | "output_id" => Ok(GeneratedField::OutputId),
7440 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7441 }
7442 }
7443 }
7444 deserializer.deserialize_identifier(GeneratedVisitor)
7445 }
7446 }
7447 struct GeneratedVisitor;
7448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7449 type Value = TaskOutputId;
7450
7451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7452 formatter.write_str("struct batch_plan.TaskOutputId")
7453 }
7454
7455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskOutputId, V::Error>
7456 where
7457 V: serde::de::MapAccess<'de>,
7458 {
7459 let mut task_id__ = None;
7460 let mut output_id__ = None;
7461 while let Some(k) = map_.next_key()? {
7462 match k {
7463 GeneratedField::TaskId => {
7464 if task_id__.is_some() {
7465 return Err(serde::de::Error::duplicate_field("taskId"));
7466 }
7467 task_id__ = map_.next_value()?;
7468 }
7469 GeneratedField::OutputId => {
7470 if output_id__.is_some() {
7471 return Err(serde::de::Error::duplicate_field("outputId"));
7472 }
7473 output_id__ =
7474 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7475 ;
7476 }
7477 }
7478 }
7479 Ok(TaskOutputId {
7480 task_id: task_id__,
7481 output_id: output_id__.unwrap_or_default(),
7482 })
7483 }
7484 }
7485 deserializer.deserialize_struct("batch_plan.TaskOutputId", FIELDS, GeneratedVisitor)
7486 }
7487}
7488impl serde::Serialize for TopNNode {
7489 #[allow(deprecated)]
7490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7491 where
7492 S: serde::Serializer,
7493 {
7494 use serde::ser::SerializeStruct;
7495 let mut len = 0;
7496 if !self.column_orders.is_empty() {
7497 len += 1;
7498 }
7499 if self.limit != 0 {
7500 len += 1;
7501 }
7502 if self.offset != 0 {
7503 len += 1;
7504 }
7505 if self.with_ties {
7506 len += 1;
7507 }
7508 let mut struct_ser = serializer.serialize_struct("batch_plan.TopNNode", len)?;
7509 if !self.column_orders.is_empty() {
7510 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7511 }
7512 if self.limit != 0 {
7513 #[allow(clippy::needless_borrow)]
7514 #[allow(clippy::needless_borrows_for_generic_args)]
7515 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
7516 }
7517 if self.offset != 0 {
7518 #[allow(clippy::needless_borrow)]
7519 #[allow(clippy::needless_borrows_for_generic_args)]
7520 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
7521 }
7522 if self.with_ties {
7523 struct_ser.serialize_field("withTies", &self.with_ties)?;
7524 }
7525 struct_ser.end()
7526 }
7527}
7528impl<'de> serde::Deserialize<'de> for TopNNode {
7529 #[allow(deprecated)]
7530 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7531 where
7532 D: serde::Deserializer<'de>,
7533 {
7534 const FIELDS: &[&str] = &[
7535 "column_orders",
7536 "columnOrders",
7537 "limit",
7538 "offset",
7539 "with_ties",
7540 "withTies",
7541 ];
7542
7543 #[allow(clippy::enum_variant_names)]
7544 enum GeneratedField {
7545 ColumnOrders,
7546 Limit,
7547 Offset,
7548 WithTies,
7549 }
7550 impl<'de> serde::Deserialize<'de> for GeneratedField {
7551 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7552 where
7553 D: serde::Deserializer<'de>,
7554 {
7555 struct GeneratedVisitor;
7556
7557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7558 type Value = GeneratedField;
7559
7560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7561 write!(formatter, "expected one of: {:?}", &FIELDS)
7562 }
7563
7564 #[allow(unused_variables)]
7565 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7566 where
7567 E: serde::de::Error,
7568 {
7569 match value {
7570 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7571 "limit" => Ok(GeneratedField::Limit),
7572 "offset" => Ok(GeneratedField::Offset),
7573 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
7574 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7575 }
7576 }
7577 }
7578 deserializer.deserialize_identifier(GeneratedVisitor)
7579 }
7580 }
7581 struct GeneratedVisitor;
7582 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7583 type Value = TopNNode;
7584
7585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7586 formatter.write_str("struct batch_plan.TopNNode")
7587 }
7588
7589 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
7590 where
7591 V: serde::de::MapAccess<'de>,
7592 {
7593 let mut column_orders__ = None;
7594 let mut limit__ = None;
7595 let mut offset__ = None;
7596 let mut with_ties__ = None;
7597 while let Some(k) = map_.next_key()? {
7598 match k {
7599 GeneratedField::ColumnOrders => {
7600 if column_orders__.is_some() {
7601 return Err(serde::de::Error::duplicate_field("columnOrders"));
7602 }
7603 column_orders__ = Some(map_.next_value()?);
7604 }
7605 GeneratedField::Limit => {
7606 if limit__.is_some() {
7607 return Err(serde::de::Error::duplicate_field("limit"));
7608 }
7609 limit__ =
7610 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7611 ;
7612 }
7613 GeneratedField::Offset => {
7614 if offset__.is_some() {
7615 return Err(serde::de::Error::duplicate_field("offset"));
7616 }
7617 offset__ =
7618 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7619 ;
7620 }
7621 GeneratedField::WithTies => {
7622 if with_ties__.is_some() {
7623 return Err(serde::de::Error::duplicate_field("withTies"));
7624 }
7625 with_ties__ = Some(map_.next_value()?);
7626 }
7627 }
7628 }
7629 Ok(TopNNode {
7630 column_orders: column_orders__.unwrap_or_default(),
7631 limit: limit__.unwrap_or_default(),
7632 offset: offset__.unwrap_or_default(),
7633 with_ties: with_ties__.unwrap_or_default(),
7634 })
7635 }
7636 }
7637 deserializer.deserialize_struct("batch_plan.TopNNode", FIELDS, GeneratedVisitor)
7638 }
7639}
7640impl serde::Serialize for UnionNode {
7641 #[allow(deprecated)]
7642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7643 where
7644 S: serde::Serializer,
7645 {
7646 use serde::ser::SerializeStruct;
7647 let len = 0;
7648 let struct_ser = serializer.serialize_struct("batch_plan.UnionNode", len)?;
7649 struct_ser.end()
7650 }
7651}
7652impl<'de> serde::Deserialize<'de> for UnionNode {
7653 #[allow(deprecated)]
7654 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7655 where
7656 D: serde::Deserializer<'de>,
7657 {
7658 const FIELDS: &[&str] = &[
7659 ];
7660
7661 #[allow(clippy::enum_variant_names)]
7662 enum GeneratedField {
7663 }
7664 impl<'de> serde::Deserialize<'de> for GeneratedField {
7665 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7666 where
7667 D: serde::Deserializer<'de>,
7668 {
7669 struct GeneratedVisitor;
7670
7671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7672 type Value = GeneratedField;
7673
7674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7675 write!(formatter, "expected one of: {:?}", &FIELDS)
7676 }
7677
7678 #[allow(unused_variables)]
7679 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7680 where
7681 E: serde::de::Error,
7682 {
7683 Err(serde::de::Error::unknown_field(value, FIELDS))
7684 }
7685 }
7686 deserializer.deserialize_identifier(GeneratedVisitor)
7687 }
7688 }
7689 struct GeneratedVisitor;
7690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7691 type Value = UnionNode;
7692
7693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7694 formatter.write_str("struct batch_plan.UnionNode")
7695 }
7696
7697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
7698 where
7699 V: serde::de::MapAccess<'de>,
7700 {
7701 while map_.next_key::<GeneratedField>()?.is_some() {
7702 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7703 }
7704 Ok(UnionNode {
7705 })
7706 }
7707 }
7708 deserializer.deserialize_struct("batch_plan.UnionNode", FIELDS, GeneratedVisitor)
7709 }
7710}
7711impl serde::Serialize for UpdateNode {
7712 #[allow(deprecated)]
7713 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7714 where
7715 S: serde::Serializer,
7716 {
7717 use serde::ser::SerializeStruct;
7718 let mut len = 0;
7719 if self.table_id != 0 {
7720 len += 1;
7721 }
7722 if self.table_version_id != 0 {
7723 len += 1;
7724 }
7725 if !self.old_exprs.is_empty() {
7726 len += 1;
7727 }
7728 if !self.new_exprs.is_empty() {
7729 len += 1;
7730 }
7731 if self.returning {
7732 len += 1;
7733 }
7734 if self.session_id != 0 {
7735 len += 1;
7736 }
7737 let mut struct_ser = serializer.serialize_struct("batch_plan.UpdateNode", len)?;
7738 if self.table_id != 0 {
7739 struct_ser.serialize_field("tableId", &self.table_id)?;
7740 }
7741 if self.table_version_id != 0 {
7742 #[allow(clippy::needless_borrow)]
7743 #[allow(clippy::needless_borrows_for_generic_args)]
7744 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
7745 }
7746 if !self.old_exprs.is_empty() {
7747 struct_ser.serialize_field("oldExprs", &self.old_exprs)?;
7748 }
7749 if !self.new_exprs.is_empty() {
7750 struct_ser.serialize_field("newExprs", &self.new_exprs)?;
7751 }
7752 if self.returning {
7753 struct_ser.serialize_field("returning", &self.returning)?;
7754 }
7755 if self.session_id != 0 {
7756 struct_ser.serialize_field("sessionId", &self.session_id)?;
7757 }
7758 struct_ser.end()
7759 }
7760}
7761impl<'de> serde::Deserialize<'de> for UpdateNode {
7762 #[allow(deprecated)]
7763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7764 where
7765 D: serde::Deserializer<'de>,
7766 {
7767 const FIELDS: &[&str] = &[
7768 "table_id",
7769 "tableId",
7770 "table_version_id",
7771 "tableVersionId",
7772 "old_exprs",
7773 "oldExprs",
7774 "new_exprs",
7775 "newExprs",
7776 "returning",
7777 "session_id",
7778 "sessionId",
7779 ];
7780
7781 #[allow(clippy::enum_variant_names)]
7782 enum GeneratedField {
7783 TableId,
7784 TableVersionId,
7785 OldExprs,
7786 NewExprs,
7787 Returning,
7788 SessionId,
7789 }
7790 impl<'de> serde::Deserialize<'de> for GeneratedField {
7791 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7792 where
7793 D: serde::Deserializer<'de>,
7794 {
7795 struct GeneratedVisitor;
7796
7797 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7798 type Value = GeneratedField;
7799
7800 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7801 write!(formatter, "expected one of: {:?}", &FIELDS)
7802 }
7803
7804 #[allow(unused_variables)]
7805 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7806 where
7807 E: serde::de::Error,
7808 {
7809 match value {
7810 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7811 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
7812 "oldExprs" | "old_exprs" => Ok(GeneratedField::OldExprs),
7813 "newExprs" | "new_exprs" => Ok(GeneratedField::NewExprs),
7814 "returning" => Ok(GeneratedField::Returning),
7815 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
7816 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7817 }
7818 }
7819 }
7820 deserializer.deserialize_identifier(GeneratedVisitor)
7821 }
7822 }
7823 struct GeneratedVisitor;
7824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7825 type Value = UpdateNode;
7826
7827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7828 formatter.write_str("struct batch_plan.UpdateNode")
7829 }
7830
7831 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateNode, V::Error>
7832 where
7833 V: serde::de::MapAccess<'de>,
7834 {
7835 let mut table_id__ = None;
7836 let mut table_version_id__ = None;
7837 let mut old_exprs__ = None;
7838 let mut new_exprs__ = None;
7839 let mut returning__ = None;
7840 let mut session_id__ = None;
7841 while let Some(k) = map_.next_key()? {
7842 match k {
7843 GeneratedField::TableId => {
7844 if table_id__.is_some() {
7845 return Err(serde::de::Error::duplicate_field("tableId"));
7846 }
7847 table_id__ =
7848 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7849 ;
7850 }
7851 GeneratedField::TableVersionId => {
7852 if table_version_id__.is_some() {
7853 return Err(serde::de::Error::duplicate_field("tableVersionId"));
7854 }
7855 table_version_id__ =
7856 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7857 ;
7858 }
7859 GeneratedField::OldExprs => {
7860 if old_exprs__.is_some() {
7861 return Err(serde::de::Error::duplicate_field("oldExprs"));
7862 }
7863 old_exprs__ = Some(map_.next_value()?);
7864 }
7865 GeneratedField::NewExprs => {
7866 if new_exprs__.is_some() {
7867 return Err(serde::de::Error::duplicate_field("newExprs"));
7868 }
7869 new_exprs__ = Some(map_.next_value()?);
7870 }
7871 GeneratedField::Returning => {
7872 if returning__.is_some() {
7873 return Err(serde::de::Error::duplicate_field("returning"));
7874 }
7875 returning__ = Some(map_.next_value()?);
7876 }
7877 GeneratedField::SessionId => {
7878 if session_id__.is_some() {
7879 return Err(serde::de::Error::duplicate_field("sessionId"));
7880 }
7881 session_id__ =
7882 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7883 ;
7884 }
7885 }
7886 }
7887 Ok(UpdateNode {
7888 table_id: table_id__.unwrap_or_default(),
7889 table_version_id: table_version_id__.unwrap_or_default(),
7890 old_exprs: old_exprs__.unwrap_or_default(),
7891 new_exprs: new_exprs__.unwrap_or_default(),
7892 returning: returning__.unwrap_or_default(),
7893 session_id: session_id__.unwrap_or_default(),
7894 })
7895 }
7896 }
7897 deserializer.deserialize_struct("batch_plan.UpdateNode", FIELDS, GeneratedVisitor)
7898 }
7899}
7900impl serde::Serialize for ValuesNode {
7901 #[allow(deprecated)]
7902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7903 where
7904 S: serde::Serializer,
7905 {
7906 use serde::ser::SerializeStruct;
7907 let mut len = 0;
7908 if !self.tuples.is_empty() {
7909 len += 1;
7910 }
7911 if !self.fields.is_empty() {
7912 len += 1;
7913 }
7914 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode", len)?;
7915 if !self.tuples.is_empty() {
7916 struct_ser.serialize_field("tuples", &self.tuples)?;
7917 }
7918 if !self.fields.is_empty() {
7919 struct_ser.serialize_field("fields", &self.fields)?;
7920 }
7921 struct_ser.end()
7922 }
7923}
7924impl<'de> serde::Deserialize<'de> for ValuesNode {
7925 #[allow(deprecated)]
7926 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7927 where
7928 D: serde::Deserializer<'de>,
7929 {
7930 const FIELDS: &[&str] = &[
7931 "tuples",
7932 "fields",
7933 ];
7934
7935 #[allow(clippy::enum_variant_names)]
7936 enum GeneratedField {
7937 Tuples,
7938 Fields,
7939 }
7940 impl<'de> serde::Deserialize<'de> for GeneratedField {
7941 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7942 where
7943 D: serde::Deserializer<'de>,
7944 {
7945 struct GeneratedVisitor;
7946
7947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7948 type Value = GeneratedField;
7949
7950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7951 write!(formatter, "expected one of: {:?}", &FIELDS)
7952 }
7953
7954 #[allow(unused_variables)]
7955 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7956 where
7957 E: serde::de::Error,
7958 {
7959 match value {
7960 "tuples" => Ok(GeneratedField::Tuples),
7961 "fields" => Ok(GeneratedField::Fields),
7962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7963 }
7964 }
7965 }
7966 deserializer.deserialize_identifier(GeneratedVisitor)
7967 }
7968 }
7969 struct GeneratedVisitor;
7970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7971 type Value = ValuesNode;
7972
7973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7974 formatter.write_str("struct batch_plan.ValuesNode")
7975 }
7976
7977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
7978 where
7979 V: serde::de::MapAccess<'de>,
7980 {
7981 let mut tuples__ = None;
7982 let mut fields__ = None;
7983 while let Some(k) = map_.next_key()? {
7984 match k {
7985 GeneratedField::Tuples => {
7986 if tuples__.is_some() {
7987 return Err(serde::de::Error::duplicate_field("tuples"));
7988 }
7989 tuples__ = Some(map_.next_value()?);
7990 }
7991 GeneratedField::Fields => {
7992 if fields__.is_some() {
7993 return Err(serde::de::Error::duplicate_field("fields"));
7994 }
7995 fields__ = Some(map_.next_value()?);
7996 }
7997 }
7998 }
7999 Ok(ValuesNode {
8000 tuples: tuples__.unwrap_or_default(),
8001 fields: fields__.unwrap_or_default(),
8002 })
8003 }
8004 }
8005 deserializer.deserialize_struct("batch_plan.ValuesNode", FIELDS, GeneratedVisitor)
8006 }
8007}
8008impl serde::Serialize for values_node::ExprTuple {
8009 #[allow(deprecated)]
8010 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8011 where
8012 S: serde::Serializer,
8013 {
8014 use serde::ser::SerializeStruct;
8015 let mut len = 0;
8016 if !self.cells.is_empty() {
8017 len += 1;
8018 }
8019 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode.ExprTuple", len)?;
8020 if !self.cells.is_empty() {
8021 struct_ser.serialize_field("cells", &self.cells)?;
8022 }
8023 struct_ser.end()
8024 }
8025}
8026impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
8027 #[allow(deprecated)]
8028 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8029 where
8030 D: serde::Deserializer<'de>,
8031 {
8032 const FIELDS: &[&str] = &[
8033 "cells",
8034 ];
8035
8036 #[allow(clippy::enum_variant_names)]
8037 enum GeneratedField {
8038 Cells,
8039 }
8040 impl<'de> serde::Deserialize<'de> for GeneratedField {
8041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8042 where
8043 D: serde::Deserializer<'de>,
8044 {
8045 struct GeneratedVisitor;
8046
8047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8048 type Value = GeneratedField;
8049
8050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8051 write!(formatter, "expected one of: {:?}", &FIELDS)
8052 }
8053
8054 #[allow(unused_variables)]
8055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8056 where
8057 E: serde::de::Error,
8058 {
8059 match value {
8060 "cells" => Ok(GeneratedField::Cells),
8061 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8062 }
8063 }
8064 }
8065 deserializer.deserialize_identifier(GeneratedVisitor)
8066 }
8067 }
8068 struct GeneratedVisitor;
8069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8070 type Value = values_node::ExprTuple;
8071
8072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8073 formatter.write_str("struct batch_plan.ValuesNode.ExprTuple")
8074 }
8075
8076 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
8077 where
8078 V: serde::de::MapAccess<'de>,
8079 {
8080 let mut cells__ = None;
8081 while let Some(k) = map_.next_key()? {
8082 match k {
8083 GeneratedField::Cells => {
8084 if cells__.is_some() {
8085 return Err(serde::de::Error::duplicate_field("cells"));
8086 }
8087 cells__ = Some(map_.next_value()?);
8088 }
8089 }
8090 }
8091 Ok(values_node::ExprTuple {
8092 cells: cells__.unwrap_or_default(),
8093 })
8094 }
8095 }
8096 deserializer.deserialize_struct("batch_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
8097 }
8098}