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::VectorIndexNearest(v) => {
5027 struct_ser.serialize_field("vectorIndexNearest", v)?;
5028 }
5029 plan_node::NodeBody::BlockExecutor(v) => {
5030 struct_ser.serialize_field("blockExecutor", v)?;
5031 }
5032 plan_node::NodeBody::BusyLoopExecutor(v) => {
5033 struct_ser.serialize_field("busyLoopExecutor", v)?;
5034 }
5035 }
5036 }
5037 struct_ser.end()
5038 }
5039}
5040impl<'de> serde::Deserialize<'de> for PlanNode {
5041 #[allow(deprecated)]
5042 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5043 where
5044 D: serde::Deserializer<'de>,
5045 {
5046 const FIELDS: &[&str] = &[
5047 "children",
5048 "identity",
5049 "insert",
5050 "delete",
5051 "update",
5052 "project",
5053 "hash_agg",
5054 "hashAgg",
5055 "filter",
5056 "exchange",
5057 "sort",
5058 "nested_loop_join",
5059 "nestedLoopJoin",
5060 "top_n",
5061 "topN",
5062 "sort_agg",
5063 "sortAgg",
5064 "row_seq_scan",
5065 "rowSeqScan",
5066 "limit",
5067 "values",
5068 "hash_join",
5069 "hashJoin",
5070 "merge_sort_exchange",
5071 "mergeSortExchange",
5072 "hop_window",
5073 "hopWindow",
5074 "table_function",
5075 "tableFunction",
5076 "sys_row_seq_scan",
5077 "sysRowSeqScan",
5078 "expand",
5079 "local_lookup_join",
5080 "localLookupJoin",
5081 "project_set",
5082 "projectSet",
5083 "union",
5084 "group_top_n",
5085 "groupTopN",
5086 "distributed_lookup_join",
5087 "distributedLookupJoin",
5088 "source",
5089 "sort_over_window",
5090 "sortOverWindow",
5091 "max_one_row",
5092 "maxOneRow",
5093 "log_row_seq_scan",
5094 "logRowSeqScan",
5095 "file_scan",
5096 "fileScan",
5097 "iceberg_scan",
5098 "icebergScan",
5099 "postgres_query",
5100 "postgresQuery",
5101 "mysql_query",
5102 "mysqlQuery",
5103 "gcs_file_scan",
5104 "gcsFileScan",
5105 "azblob_file_scan",
5106 "azblobFileScan",
5107 "vector_index_nearest",
5108 "vectorIndexNearest",
5109 "block_executor",
5110 "blockExecutor",
5111 "busy_loop_executor",
5112 "busyLoopExecutor",
5113 ];
5114
5115 #[allow(clippy::enum_variant_names)]
5116 enum GeneratedField {
5117 Children,
5118 Identity,
5119 Insert,
5120 Delete,
5121 Update,
5122 Project,
5123 HashAgg,
5124 Filter,
5125 Exchange,
5126 Sort,
5127 NestedLoopJoin,
5128 TopN,
5129 SortAgg,
5130 RowSeqScan,
5131 Limit,
5132 Values,
5133 HashJoin,
5134 MergeSortExchange,
5135 HopWindow,
5136 TableFunction,
5137 SysRowSeqScan,
5138 Expand,
5139 LocalLookupJoin,
5140 ProjectSet,
5141 Union,
5142 GroupTopN,
5143 DistributedLookupJoin,
5144 Source,
5145 SortOverWindow,
5146 MaxOneRow,
5147 LogRowSeqScan,
5148 FileScan,
5149 IcebergScan,
5150 PostgresQuery,
5151 MysqlQuery,
5152 GcsFileScan,
5153 AzblobFileScan,
5154 VectorIndexNearest,
5155 BlockExecutor,
5156 BusyLoopExecutor,
5157 }
5158 impl<'de> serde::Deserialize<'de> for GeneratedField {
5159 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5160 where
5161 D: serde::Deserializer<'de>,
5162 {
5163 struct GeneratedVisitor;
5164
5165 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5166 type Value = GeneratedField;
5167
5168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5169 write!(formatter, "expected one of: {:?}", &FIELDS)
5170 }
5171
5172 #[allow(unused_variables)]
5173 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5174 where
5175 E: serde::de::Error,
5176 {
5177 match value {
5178 "children" => Ok(GeneratedField::Children),
5179 "identity" => Ok(GeneratedField::Identity),
5180 "insert" => Ok(GeneratedField::Insert),
5181 "delete" => Ok(GeneratedField::Delete),
5182 "update" => Ok(GeneratedField::Update),
5183 "project" => Ok(GeneratedField::Project),
5184 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
5185 "filter" => Ok(GeneratedField::Filter),
5186 "exchange" => Ok(GeneratedField::Exchange),
5187 "sort" => Ok(GeneratedField::Sort),
5188 "nestedLoopJoin" | "nested_loop_join" => Ok(GeneratedField::NestedLoopJoin),
5189 "topN" | "top_n" => Ok(GeneratedField::TopN),
5190 "sortAgg" | "sort_agg" => Ok(GeneratedField::SortAgg),
5191 "rowSeqScan" | "row_seq_scan" => Ok(GeneratedField::RowSeqScan),
5192 "limit" => Ok(GeneratedField::Limit),
5193 "values" => Ok(GeneratedField::Values),
5194 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
5195 "mergeSortExchange" | "merge_sort_exchange" => Ok(GeneratedField::MergeSortExchange),
5196 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
5197 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
5198 "sysRowSeqScan" | "sys_row_seq_scan" => Ok(GeneratedField::SysRowSeqScan),
5199 "expand" => Ok(GeneratedField::Expand),
5200 "localLookupJoin" | "local_lookup_join" => Ok(GeneratedField::LocalLookupJoin),
5201 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
5202 "union" => Ok(GeneratedField::Union),
5203 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
5204 "distributedLookupJoin" | "distributed_lookup_join" => Ok(GeneratedField::DistributedLookupJoin),
5205 "source" => Ok(GeneratedField::Source),
5206 "sortOverWindow" | "sort_over_window" => Ok(GeneratedField::SortOverWindow),
5207 "maxOneRow" | "max_one_row" => Ok(GeneratedField::MaxOneRow),
5208 "logRowSeqScan" | "log_row_seq_scan" => Ok(GeneratedField::LogRowSeqScan),
5209 "fileScan" | "file_scan" => Ok(GeneratedField::FileScan),
5210 "icebergScan" | "iceberg_scan" => Ok(GeneratedField::IcebergScan),
5211 "postgresQuery" | "postgres_query" => Ok(GeneratedField::PostgresQuery),
5212 "mysqlQuery" | "mysql_query" => Ok(GeneratedField::MysqlQuery),
5213 "gcsFileScan" | "gcs_file_scan" => Ok(GeneratedField::GcsFileScan),
5214 "azblobFileScan" | "azblob_file_scan" => Ok(GeneratedField::AzblobFileScan),
5215 "vectorIndexNearest" | "vector_index_nearest" => Ok(GeneratedField::VectorIndexNearest),
5216 "blockExecutor" | "block_executor" => Ok(GeneratedField::BlockExecutor),
5217 "busyLoopExecutor" | "busy_loop_executor" => Ok(GeneratedField::BusyLoopExecutor),
5218 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5219 }
5220 }
5221 }
5222 deserializer.deserialize_identifier(GeneratedVisitor)
5223 }
5224 }
5225 struct GeneratedVisitor;
5226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5227 type Value = PlanNode;
5228
5229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5230 formatter.write_str("struct batch_plan.PlanNode")
5231 }
5232
5233 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanNode, V::Error>
5234 where
5235 V: serde::de::MapAccess<'de>,
5236 {
5237 let mut children__ = None;
5238 let mut identity__ = None;
5239 let mut node_body__ = None;
5240 while let Some(k) = map_.next_key()? {
5241 match k {
5242 GeneratedField::Children => {
5243 if children__.is_some() {
5244 return Err(serde::de::Error::duplicate_field("children"));
5245 }
5246 children__ = Some(map_.next_value()?);
5247 }
5248 GeneratedField::Identity => {
5249 if identity__.is_some() {
5250 return Err(serde::de::Error::duplicate_field("identity"));
5251 }
5252 identity__ = Some(map_.next_value()?);
5253 }
5254 GeneratedField::Insert => {
5255 if node_body__.is_some() {
5256 return Err(serde::de::Error::duplicate_field("insert"));
5257 }
5258 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Insert)
5259;
5260 }
5261 GeneratedField::Delete => {
5262 if node_body__.is_some() {
5263 return Err(serde::de::Error::duplicate_field("delete"));
5264 }
5265 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Delete)
5266;
5267 }
5268 GeneratedField::Update => {
5269 if node_body__.is_some() {
5270 return Err(serde::de::Error::duplicate_field("update"));
5271 }
5272 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Update)
5273;
5274 }
5275 GeneratedField::Project => {
5276 if node_body__.is_some() {
5277 return Err(serde::de::Error::duplicate_field("project"));
5278 }
5279 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Project)
5280;
5281 }
5282 GeneratedField::HashAgg => {
5283 if node_body__.is_some() {
5284 return Err(serde::de::Error::duplicate_field("hashAgg"));
5285 }
5286 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashAgg)
5287;
5288 }
5289 GeneratedField::Filter => {
5290 if node_body__.is_some() {
5291 return Err(serde::de::Error::duplicate_field("filter"));
5292 }
5293 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Filter)
5294;
5295 }
5296 GeneratedField::Exchange => {
5297 if node_body__.is_some() {
5298 return Err(serde::de::Error::duplicate_field("exchange"));
5299 }
5300 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Exchange)
5301;
5302 }
5303 GeneratedField::Sort => {
5304 if node_body__.is_some() {
5305 return Err(serde::de::Error::duplicate_field("sort"));
5306 }
5307 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Sort)
5308;
5309 }
5310 GeneratedField::NestedLoopJoin => {
5311 if node_body__.is_some() {
5312 return Err(serde::de::Error::duplicate_field("nestedLoopJoin"));
5313 }
5314 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::NestedLoopJoin)
5315;
5316 }
5317 GeneratedField::TopN => {
5318 if node_body__.is_some() {
5319 return Err(serde::de::Error::duplicate_field("topN"));
5320 }
5321 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TopN)
5322;
5323 }
5324 GeneratedField::SortAgg => {
5325 if node_body__.is_some() {
5326 return Err(serde::de::Error::duplicate_field("sortAgg"));
5327 }
5328 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortAgg)
5329;
5330 }
5331 GeneratedField::RowSeqScan => {
5332 if node_body__.is_some() {
5333 return Err(serde::de::Error::duplicate_field("rowSeqScan"));
5334 }
5335 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::RowSeqScan)
5336;
5337 }
5338 GeneratedField::Limit => {
5339 if node_body__.is_some() {
5340 return Err(serde::de::Error::duplicate_field("limit"));
5341 }
5342 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Limit)
5343;
5344 }
5345 GeneratedField::Values => {
5346 if node_body__.is_some() {
5347 return Err(serde::de::Error::duplicate_field("values"));
5348 }
5349 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Values)
5350;
5351 }
5352 GeneratedField::HashJoin => {
5353 if node_body__.is_some() {
5354 return Err(serde::de::Error::duplicate_field("hashJoin"));
5355 }
5356 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashJoin)
5357;
5358 }
5359 GeneratedField::MergeSortExchange => {
5360 if node_body__.is_some() {
5361 return Err(serde::de::Error::duplicate_field("mergeSortExchange"));
5362 }
5363 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MergeSortExchange)
5364;
5365 }
5366 GeneratedField::HopWindow => {
5367 if node_body__.is_some() {
5368 return Err(serde::de::Error::duplicate_field("hopWindow"));
5369 }
5370 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HopWindow)
5371;
5372 }
5373 GeneratedField::TableFunction => {
5374 if node_body__.is_some() {
5375 return Err(serde::de::Error::duplicate_field("tableFunction"));
5376 }
5377 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TableFunction)
5378;
5379 }
5380 GeneratedField::SysRowSeqScan => {
5381 if node_body__.is_some() {
5382 return Err(serde::de::Error::duplicate_field("sysRowSeqScan"));
5383 }
5384 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SysRowSeqScan)
5385;
5386 }
5387 GeneratedField::Expand => {
5388 if node_body__.is_some() {
5389 return Err(serde::de::Error::duplicate_field("expand"));
5390 }
5391 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Expand)
5392;
5393 }
5394 GeneratedField::LocalLookupJoin => {
5395 if node_body__.is_some() {
5396 return Err(serde::de::Error::duplicate_field("localLookupJoin"));
5397 }
5398 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LocalLookupJoin)
5399;
5400 }
5401 GeneratedField::ProjectSet => {
5402 if node_body__.is_some() {
5403 return Err(serde::de::Error::duplicate_field("projectSet"));
5404 }
5405 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::ProjectSet)
5406;
5407 }
5408 GeneratedField::Union => {
5409 if node_body__.is_some() {
5410 return Err(serde::de::Error::duplicate_field("union"));
5411 }
5412 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Union)
5413;
5414 }
5415 GeneratedField::GroupTopN => {
5416 if node_body__.is_some() {
5417 return Err(serde::de::Error::duplicate_field("groupTopN"));
5418 }
5419 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GroupTopN)
5420;
5421 }
5422 GeneratedField::DistributedLookupJoin => {
5423 if node_body__.is_some() {
5424 return Err(serde::de::Error::duplicate_field("distributedLookupJoin"));
5425 }
5426 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::DistributedLookupJoin)
5427;
5428 }
5429 GeneratedField::Source => {
5430 if node_body__.is_some() {
5431 return Err(serde::de::Error::duplicate_field("source"));
5432 }
5433 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Source)
5434;
5435 }
5436 GeneratedField::SortOverWindow => {
5437 if node_body__.is_some() {
5438 return Err(serde::de::Error::duplicate_field("sortOverWindow"));
5439 }
5440 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortOverWindow)
5441;
5442 }
5443 GeneratedField::MaxOneRow => {
5444 if node_body__.is_some() {
5445 return Err(serde::de::Error::duplicate_field("maxOneRow"));
5446 }
5447 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MaxOneRow)
5448;
5449 }
5450 GeneratedField::LogRowSeqScan => {
5451 if node_body__.is_some() {
5452 return Err(serde::de::Error::duplicate_field("logRowSeqScan"));
5453 }
5454 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LogRowSeqScan)
5455;
5456 }
5457 GeneratedField::FileScan => {
5458 if node_body__.is_some() {
5459 return Err(serde::de::Error::duplicate_field("fileScan"));
5460 }
5461 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::FileScan)
5462;
5463 }
5464 GeneratedField::IcebergScan => {
5465 if node_body__.is_some() {
5466 return Err(serde::de::Error::duplicate_field("icebergScan"));
5467 }
5468 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergScan)
5469;
5470 }
5471 GeneratedField::PostgresQuery => {
5472 if node_body__.is_some() {
5473 return Err(serde::de::Error::duplicate_field("postgresQuery"));
5474 }
5475 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::PostgresQuery)
5476;
5477 }
5478 GeneratedField::MysqlQuery => {
5479 if node_body__.is_some() {
5480 return Err(serde::de::Error::duplicate_field("mysqlQuery"));
5481 }
5482 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MysqlQuery)
5483;
5484 }
5485 GeneratedField::GcsFileScan => {
5486 if node_body__.is_some() {
5487 return Err(serde::de::Error::duplicate_field("gcsFileScan"));
5488 }
5489 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GcsFileScan)
5490;
5491 }
5492 GeneratedField::AzblobFileScan => {
5493 if node_body__.is_some() {
5494 return Err(serde::de::Error::duplicate_field("azblobFileScan"));
5495 }
5496 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::AzblobFileScan)
5497;
5498 }
5499 GeneratedField::VectorIndexNearest => {
5500 if node_body__.is_some() {
5501 return Err(serde::de::Error::duplicate_field("vectorIndexNearest"));
5502 }
5503 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::VectorIndexNearest)
5504;
5505 }
5506 GeneratedField::BlockExecutor => {
5507 if node_body__.is_some() {
5508 return Err(serde::de::Error::duplicate_field("blockExecutor"));
5509 }
5510 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BlockExecutor);
5511 }
5512 GeneratedField::BusyLoopExecutor => {
5513 if node_body__.is_some() {
5514 return Err(serde::de::Error::duplicate_field("busyLoopExecutor"));
5515 }
5516 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BusyLoopExecutor);
5517 }
5518 }
5519 }
5520 Ok(PlanNode {
5521 children: children__.unwrap_or_default(),
5522 identity: identity__.unwrap_or_default(),
5523 node_body: node_body__,
5524 })
5525 }
5526 }
5527 deserializer.deserialize_struct("batch_plan.PlanNode", FIELDS, GeneratedVisitor)
5528 }
5529}
5530impl serde::Serialize for PostgresQueryNode {
5531 #[allow(deprecated)]
5532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5533 where
5534 S: serde::Serializer,
5535 {
5536 use serde::ser::SerializeStruct;
5537 let mut len = 0;
5538 if !self.columns.is_empty() {
5539 len += 1;
5540 }
5541 if !self.hostname.is_empty() {
5542 len += 1;
5543 }
5544 if !self.port.is_empty() {
5545 len += 1;
5546 }
5547 if !self.username.is_empty() {
5548 len += 1;
5549 }
5550 if !self.password.is_empty() {
5551 len += 1;
5552 }
5553 if !self.database.is_empty() {
5554 len += 1;
5555 }
5556 if !self.query.is_empty() {
5557 len += 1;
5558 }
5559 let mut struct_ser = serializer.serialize_struct("batch_plan.PostgresQueryNode", len)?;
5560 if !self.columns.is_empty() {
5561 struct_ser.serialize_field("columns", &self.columns)?;
5562 }
5563 if !self.hostname.is_empty() {
5564 struct_ser.serialize_field("hostname", &self.hostname)?;
5565 }
5566 if !self.port.is_empty() {
5567 struct_ser.serialize_field("port", &self.port)?;
5568 }
5569 if !self.username.is_empty() {
5570 struct_ser.serialize_field("username", &self.username)?;
5571 }
5572 if !self.password.is_empty() {
5573 struct_ser.serialize_field("password", &self.password)?;
5574 }
5575 if !self.database.is_empty() {
5576 struct_ser.serialize_field("database", &self.database)?;
5577 }
5578 if !self.query.is_empty() {
5579 struct_ser.serialize_field("query", &self.query)?;
5580 }
5581 struct_ser.end()
5582 }
5583}
5584impl<'de> serde::Deserialize<'de> for PostgresQueryNode {
5585 #[allow(deprecated)]
5586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5587 where
5588 D: serde::Deserializer<'de>,
5589 {
5590 const FIELDS: &[&str] = &[
5591 "columns",
5592 "hostname",
5593 "port",
5594 "username",
5595 "password",
5596 "database",
5597 "query",
5598 ];
5599
5600 #[allow(clippy::enum_variant_names)]
5601 enum GeneratedField {
5602 Columns,
5603 Hostname,
5604 Port,
5605 Username,
5606 Password,
5607 Database,
5608 Query,
5609 }
5610 impl<'de> serde::Deserialize<'de> for GeneratedField {
5611 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5612 where
5613 D: serde::Deserializer<'de>,
5614 {
5615 struct GeneratedVisitor;
5616
5617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5618 type Value = GeneratedField;
5619
5620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5621 write!(formatter, "expected one of: {:?}", &FIELDS)
5622 }
5623
5624 #[allow(unused_variables)]
5625 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5626 where
5627 E: serde::de::Error,
5628 {
5629 match value {
5630 "columns" => Ok(GeneratedField::Columns),
5631 "hostname" => Ok(GeneratedField::Hostname),
5632 "port" => Ok(GeneratedField::Port),
5633 "username" => Ok(GeneratedField::Username),
5634 "password" => Ok(GeneratedField::Password),
5635 "database" => Ok(GeneratedField::Database),
5636 "query" => Ok(GeneratedField::Query),
5637 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5638 }
5639 }
5640 }
5641 deserializer.deserialize_identifier(GeneratedVisitor)
5642 }
5643 }
5644 struct GeneratedVisitor;
5645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5646 type Value = PostgresQueryNode;
5647
5648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5649 formatter.write_str("struct batch_plan.PostgresQueryNode")
5650 }
5651
5652 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PostgresQueryNode, V::Error>
5653 where
5654 V: serde::de::MapAccess<'de>,
5655 {
5656 let mut columns__ = None;
5657 let mut hostname__ = None;
5658 let mut port__ = None;
5659 let mut username__ = None;
5660 let mut password__ = None;
5661 let mut database__ = None;
5662 let mut query__ = None;
5663 while let Some(k) = map_.next_key()? {
5664 match k {
5665 GeneratedField::Columns => {
5666 if columns__.is_some() {
5667 return Err(serde::de::Error::duplicate_field("columns"));
5668 }
5669 columns__ = Some(map_.next_value()?);
5670 }
5671 GeneratedField::Hostname => {
5672 if hostname__.is_some() {
5673 return Err(serde::de::Error::duplicate_field("hostname"));
5674 }
5675 hostname__ = Some(map_.next_value()?);
5676 }
5677 GeneratedField::Port => {
5678 if port__.is_some() {
5679 return Err(serde::de::Error::duplicate_field("port"));
5680 }
5681 port__ = Some(map_.next_value()?);
5682 }
5683 GeneratedField::Username => {
5684 if username__.is_some() {
5685 return Err(serde::de::Error::duplicate_field("username"));
5686 }
5687 username__ = Some(map_.next_value()?);
5688 }
5689 GeneratedField::Password => {
5690 if password__.is_some() {
5691 return Err(serde::de::Error::duplicate_field("password"));
5692 }
5693 password__ = Some(map_.next_value()?);
5694 }
5695 GeneratedField::Database => {
5696 if database__.is_some() {
5697 return Err(serde::de::Error::duplicate_field("database"));
5698 }
5699 database__ = Some(map_.next_value()?);
5700 }
5701 GeneratedField::Query => {
5702 if query__.is_some() {
5703 return Err(serde::de::Error::duplicate_field("query"));
5704 }
5705 query__ = Some(map_.next_value()?);
5706 }
5707 }
5708 }
5709 Ok(PostgresQueryNode {
5710 columns: columns__.unwrap_or_default(),
5711 hostname: hostname__.unwrap_or_default(),
5712 port: port__.unwrap_or_default(),
5713 username: username__.unwrap_or_default(),
5714 password: password__.unwrap_or_default(),
5715 database: database__.unwrap_or_default(),
5716 query: query__.unwrap_or_default(),
5717 })
5718 }
5719 }
5720 deserializer.deserialize_struct("batch_plan.PostgresQueryNode", FIELDS, GeneratedVisitor)
5721 }
5722}
5723impl serde::Serialize for ProjectNode {
5724 #[allow(deprecated)]
5725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5726 where
5727 S: serde::Serializer,
5728 {
5729 use serde::ser::SerializeStruct;
5730 let mut len = 0;
5731 if !self.select_list.is_empty() {
5732 len += 1;
5733 }
5734 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectNode", len)?;
5735 if !self.select_list.is_empty() {
5736 struct_ser.serialize_field("selectList", &self.select_list)?;
5737 }
5738 struct_ser.end()
5739 }
5740}
5741impl<'de> serde::Deserialize<'de> for ProjectNode {
5742 #[allow(deprecated)]
5743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5744 where
5745 D: serde::Deserializer<'de>,
5746 {
5747 const FIELDS: &[&str] = &[
5748 "select_list",
5749 "selectList",
5750 ];
5751
5752 #[allow(clippy::enum_variant_names)]
5753 enum GeneratedField {
5754 SelectList,
5755 }
5756 impl<'de> serde::Deserialize<'de> for GeneratedField {
5757 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5758 where
5759 D: serde::Deserializer<'de>,
5760 {
5761 struct GeneratedVisitor;
5762
5763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5764 type Value = GeneratedField;
5765
5766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5767 write!(formatter, "expected one of: {:?}", &FIELDS)
5768 }
5769
5770 #[allow(unused_variables)]
5771 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5772 where
5773 E: serde::de::Error,
5774 {
5775 match value {
5776 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5778 }
5779 }
5780 }
5781 deserializer.deserialize_identifier(GeneratedVisitor)
5782 }
5783 }
5784 struct GeneratedVisitor;
5785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5786 type Value = ProjectNode;
5787
5788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5789 formatter.write_str("struct batch_plan.ProjectNode")
5790 }
5791
5792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
5793 where
5794 V: serde::de::MapAccess<'de>,
5795 {
5796 let mut select_list__ = None;
5797 while let Some(k) = map_.next_key()? {
5798 match k {
5799 GeneratedField::SelectList => {
5800 if select_list__.is_some() {
5801 return Err(serde::de::Error::duplicate_field("selectList"));
5802 }
5803 select_list__ = Some(map_.next_value()?);
5804 }
5805 }
5806 }
5807 Ok(ProjectNode {
5808 select_list: select_list__.unwrap_or_default(),
5809 })
5810 }
5811 }
5812 deserializer.deserialize_struct("batch_plan.ProjectNode", FIELDS, GeneratedVisitor)
5813 }
5814}
5815impl serde::Serialize for ProjectSetNode {
5816 #[allow(deprecated)]
5817 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5818 where
5819 S: serde::Serializer,
5820 {
5821 use serde::ser::SerializeStruct;
5822 let mut len = 0;
5823 if !self.select_list.is_empty() {
5824 len += 1;
5825 }
5826 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectSetNode", len)?;
5827 if !self.select_list.is_empty() {
5828 struct_ser.serialize_field("selectList", &self.select_list)?;
5829 }
5830 struct_ser.end()
5831 }
5832}
5833impl<'de> serde::Deserialize<'de> for ProjectSetNode {
5834 #[allow(deprecated)]
5835 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5836 where
5837 D: serde::Deserializer<'de>,
5838 {
5839 const FIELDS: &[&str] = &[
5840 "select_list",
5841 "selectList",
5842 ];
5843
5844 #[allow(clippy::enum_variant_names)]
5845 enum GeneratedField {
5846 SelectList,
5847 }
5848 impl<'de> serde::Deserialize<'de> for GeneratedField {
5849 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5850 where
5851 D: serde::Deserializer<'de>,
5852 {
5853 struct GeneratedVisitor;
5854
5855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5856 type Value = GeneratedField;
5857
5858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5859 write!(formatter, "expected one of: {:?}", &FIELDS)
5860 }
5861
5862 #[allow(unused_variables)]
5863 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5864 where
5865 E: serde::de::Error,
5866 {
5867 match value {
5868 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5869 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5870 }
5871 }
5872 }
5873 deserializer.deserialize_identifier(GeneratedVisitor)
5874 }
5875 }
5876 struct GeneratedVisitor;
5877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5878 type Value = ProjectSetNode;
5879
5880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5881 formatter.write_str("struct batch_plan.ProjectSetNode")
5882 }
5883
5884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
5885 where
5886 V: serde::de::MapAccess<'de>,
5887 {
5888 let mut select_list__ = None;
5889 while let Some(k) = map_.next_key()? {
5890 match k {
5891 GeneratedField::SelectList => {
5892 if select_list__.is_some() {
5893 return Err(serde::de::Error::duplicate_field("selectList"));
5894 }
5895 select_list__ = Some(map_.next_value()?);
5896 }
5897 }
5898 }
5899 Ok(ProjectSetNode {
5900 select_list: select_list__.unwrap_or_default(),
5901 })
5902 }
5903 }
5904 deserializer.deserialize_struct("batch_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
5905 }
5906}
5907impl serde::Serialize for RowSeqScanNode {
5908 #[allow(deprecated)]
5909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5910 where
5911 S: serde::Serializer,
5912 {
5913 use serde::ser::SerializeStruct;
5914 let mut len = 0;
5915 if self.table_desc.is_some() {
5916 len += 1;
5917 }
5918 if !self.column_ids.is_empty() {
5919 len += 1;
5920 }
5921 if !self.scan_ranges.is_empty() {
5922 len += 1;
5923 }
5924 if self.vnode_bitmap.is_some() {
5925 len += 1;
5926 }
5927 if self.ordered {
5928 len += 1;
5929 }
5930 if self.limit.is_some() {
5931 len += 1;
5932 }
5933 if self.as_of.is_some() {
5934 len += 1;
5935 }
5936 let mut struct_ser = serializer.serialize_struct("batch_plan.RowSeqScanNode", len)?;
5937 if let Some(v) = self.table_desc.as_ref() {
5938 struct_ser.serialize_field("tableDesc", v)?;
5939 }
5940 if !self.column_ids.is_empty() {
5941 struct_ser.serialize_field("columnIds", &self.column_ids)?;
5942 }
5943 if !self.scan_ranges.is_empty() {
5944 struct_ser.serialize_field("scanRanges", &self.scan_ranges)?;
5945 }
5946 if let Some(v) = self.vnode_bitmap.as_ref() {
5947 struct_ser.serialize_field("vnodeBitmap", v)?;
5948 }
5949 if self.ordered {
5950 struct_ser.serialize_field("ordered", &self.ordered)?;
5951 }
5952 if let Some(v) = self.limit.as_ref() {
5953 #[allow(clippy::needless_borrow)]
5954 #[allow(clippy::needless_borrows_for_generic_args)]
5955 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
5956 }
5957 if let Some(v) = self.as_of.as_ref() {
5958 struct_ser.serialize_field("asOf", v)?;
5959 }
5960 struct_ser.end()
5961 }
5962}
5963impl<'de> serde::Deserialize<'de> for RowSeqScanNode {
5964 #[allow(deprecated)]
5965 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5966 where
5967 D: serde::Deserializer<'de>,
5968 {
5969 const FIELDS: &[&str] = &[
5970 "table_desc",
5971 "tableDesc",
5972 "column_ids",
5973 "columnIds",
5974 "scan_ranges",
5975 "scanRanges",
5976 "vnode_bitmap",
5977 "vnodeBitmap",
5978 "ordered",
5979 "limit",
5980 "as_of",
5981 "asOf",
5982 ];
5983
5984 #[allow(clippy::enum_variant_names)]
5985 enum GeneratedField {
5986 TableDesc,
5987 ColumnIds,
5988 ScanRanges,
5989 VnodeBitmap,
5990 Ordered,
5991 Limit,
5992 AsOf,
5993 }
5994 impl<'de> serde::Deserialize<'de> for GeneratedField {
5995 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5996 where
5997 D: serde::Deserializer<'de>,
5998 {
5999 struct GeneratedVisitor;
6000
6001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6002 type Value = GeneratedField;
6003
6004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6005 write!(formatter, "expected one of: {:?}", &FIELDS)
6006 }
6007
6008 #[allow(unused_variables)]
6009 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6010 where
6011 E: serde::de::Error,
6012 {
6013 match value {
6014 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
6015 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
6016 "scanRanges" | "scan_ranges" => Ok(GeneratedField::ScanRanges),
6017 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
6018 "ordered" => Ok(GeneratedField::Ordered),
6019 "limit" => Ok(GeneratedField::Limit),
6020 "asOf" | "as_of" => Ok(GeneratedField::AsOf),
6021 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6022 }
6023 }
6024 }
6025 deserializer.deserialize_identifier(GeneratedVisitor)
6026 }
6027 }
6028 struct GeneratedVisitor;
6029 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6030 type Value = RowSeqScanNode;
6031
6032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6033 formatter.write_str("struct batch_plan.RowSeqScanNode")
6034 }
6035
6036 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowSeqScanNode, V::Error>
6037 where
6038 V: serde::de::MapAccess<'de>,
6039 {
6040 let mut table_desc__ = None;
6041 let mut column_ids__ = None;
6042 let mut scan_ranges__ = None;
6043 let mut vnode_bitmap__ = None;
6044 let mut ordered__ = None;
6045 let mut limit__ = None;
6046 let mut as_of__ = None;
6047 while let Some(k) = map_.next_key()? {
6048 match k {
6049 GeneratedField::TableDesc => {
6050 if table_desc__.is_some() {
6051 return Err(serde::de::Error::duplicate_field("tableDesc"));
6052 }
6053 table_desc__ = map_.next_value()?;
6054 }
6055 GeneratedField::ColumnIds => {
6056 if column_ids__.is_some() {
6057 return Err(serde::de::Error::duplicate_field("columnIds"));
6058 }
6059 column_ids__ =
6060 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6061 .into_iter().map(|x| x.0).collect())
6062 ;
6063 }
6064 GeneratedField::ScanRanges => {
6065 if scan_ranges__.is_some() {
6066 return Err(serde::de::Error::duplicate_field("scanRanges"));
6067 }
6068 scan_ranges__ = Some(map_.next_value()?);
6069 }
6070 GeneratedField::VnodeBitmap => {
6071 if vnode_bitmap__.is_some() {
6072 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
6073 }
6074 vnode_bitmap__ = map_.next_value()?;
6075 }
6076 GeneratedField::Ordered => {
6077 if ordered__.is_some() {
6078 return Err(serde::de::Error::duplicate_field("ordered"));
6079 }
6080 ordered__ = Some(map_.next_value()?);
6081 }
6082 GeneratedField::Limit => {
6083 if limit__.is_some() {
6084 return Err(serde::de::Error::duplicate_field("limit"));
6085 }
6086 limit__ =
6087 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6088 ;
6089 }
6090 GeneratedField::AsOf => {
6091 if as_of__.is_some() {
6092 return Err(serde::de::Error::duplicate_field("asOf"));
6093 }
6094 as_of__ = map_.next_value()?;
6095 }
6096 }
6097 }
6098 Ok(RowSeqScanNode {
6099 table_desc: table_desc__,
6100 column_ids: column_ids__.unwrap_or_default(),
6101 scan_ranges: scan_ranges__.unwrap_or_default(),
6102 vnode_bitmap: vnode_bitmap__,
6103 ordered: ordered__.unwrap_or_default(),
6104 limit: limit__,
6105 as_of: as_of__,
6106 })
6107 }
6108 }
6109 deserializer.deserialize_struct("batch_plan.RowSeqScanNode", FIELDS, GeneratedVisitor)
6110 }
6111}
6112impl serde::Serialize for ScanRange {
6113 #[allow(deprecated)]
6114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6115 where
6116 S: serde::Serializer,
6117 {
6118 use serde::ser::SerializeStruct;
6119 let mut len = 0;
6120 if !self.eq_conds.is_empty() {
6121 len += 1;
6122 }
6123 if self.lower_bound.is_some() {
6124 len += 1;
6125 }
6126 if self.upper_bound.is_some() {
6127 len += 1;
6128 }
6129 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange", len)?;
6130 if !self.eq_conds.is_empty() {
6131 struct_ser.serialize_field("eqConds", &self.eq_conds.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6132 }
6133 if let Some(v) = self.lower_bound.as_ref() {
6134 struct_ser.serialize_field("lowerBound", v)?;
6135 }
6136 if let Some(v) = self.upper_bound.as_ref() {
6137 struct_ser.serialize_field("upperBound", v)?;
6138 }
6139 struct_ser.end()
6140 }
6141}
6142impl<'de> serde::Deserialize<'de> for ScanRange {
6143 #[allow(deprecated)]
6144 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6145 where
6146 D: serde::Deserializer<'de>,
6147 {
6148 const FIELDS: &[&str] = &[
6149 "eq_conds",
6150 "eqConds",
6151 "lower_bound",
6152 "lowerBound",
6153 "upper_bound",
6154 "upperBound",
6155 ];
6156
6157 #[allow(clippy::enum_variant_names)]
6158 enum GeneratedField {
6159 EqConds,
6160 LowerBound,
6161 UpperBound,
6162 }
6163 impl<'de> serde::Deserialize<'de> for GeneratedField {
6164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6165 where
6166 D: serde::Deserializer<'de>,
6167 {
6168 struct GeneratedVisitor;
6169
6170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6171 type Value = GeneratedField;
6172
6173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6174 write!(formatter, "expected one of: {:?}", &FIELDS)
6175 }
6176
6177 #[allow(unused_variables)]
6178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6179 where
6180 E: serde::de::Error,
6181 {
6182 match value {
6183 "eqConds" | "eq_conds" => Ok(GeneratedField::EqConds),
6184 "lowerBound" | "lower_bound" => Ok(GeneratedField::LowerBound),
6185 "upperBound" | "upper_bound" => Ok(GeneratedField::UpperBound),
6186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6187 }
6188 }
6189 }
6190 deserializer.deserialize_identifier(GeneratedVisitor)
6191 }
6192 }
6193 struct GeneratedVisitor;
6194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6195 type Value = ScanRange;
6196
6197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6198 formatter.write_str("struct batch_plan.ScanRange")
6199 }
6200
6201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScanRange, V::Error>
6202 where
6203 V: serde::de::MapAccess<'de>,
6204 {
6205 let mut eq_conds__ = None;
6206 let mut lower_bound__ = None;
6207 let mut upper_bound__ = None;
6208 while let Some(k) = map_.next_key()? {
6209 match k {
6210 GeneratedField::EqConds => {
6211 if eq_conds__.is_some() {
6212 return Err(serde::de::Error::duplicate_field("eqConds"));
6213 }
6214 eq_conds__ =
6215 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6216 .into_iter().map(|x| x.0).collect())
6217 ;
6218 }
6219 GeneratedField::LowerBound => {
6220 if lower_bound__.is_some() {
6221 return Err(serde::de::Error::duplicate_field("lowerBound"));
6222 }
6223 lower_bound__ = map_.next_value()?;
6224 }
6225 GeneratedField::UpperBound => {
6226 if upper_bound__.is_some() {
6227 return Err(serde::de::Error::duplicate_field("upperBound"));
6228 }
6229 upper_bound__ = map_.next_value()?;
6230 }
6231 }
6232 }
6233 Ok(ScanRange {
6234 eq_conds: eq_conds__.unwrap_or_default(),
6235 lower_bound: lower_bound__,
6236 upper_bound: upper_bound__,
6237 })
6238 }
6239 }
6240 deserializer.deserialize_struct("batch_plan.ScanRange", FIELDS, GeneratedVisitor)
6241 }
6242}
6243impl serde::Serialize for scan_range::Bound {
6244 #[allow(deprecated)]
6245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6246 where
6247 S: serde::Serializer,
6248 {
6249 use serde::ser::SerializeStruct;
6250 let mut len = 0;
6251 if !self.value.is_empty() {
6252 len += 1;
6253 }
6254 if self.inclusive {
6255 len += 1;
6256 }
6257 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange.Bound", len)?;
6258 if !self.value.is_empty() {
6259 struct_ser.serialize_field("value", &self.value.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6260 }
6261 if self.inclusive {
6262 struct_ser.serialize_field("inclusive", &self.inclusive)?;
6263 }
6264 struct_ser.end()
6265 }
6266}
6267impl<'de> serde::Deserialize<'de> for scan_range::Bound {
6268 #[allow(deprecated)]
6269 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6270 where
6271 D: serde::Deserializer<'de>,
6272 {
6273 const FIELDS: &[&str] = &[
6274 "value",
6275 "inclusive",
6276 ];
6277
6278 #[allow(clippy::enum_variant_names)]
6279 enum GeneratedField {
6280 Value,
6281 Inclusive,
6282 }
6283 impl<'de> serde::Deserialize<'de> for GeneratedField {
6284 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6285 where
6286 D: serde::Deserializer<'de>,
6287 {
6288 struct GeneratedVisitor;
6289
6290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6291 type Value = GeneratedField;
6292
6293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6294 write!(formatter, "expected one of: {:?}", &FIELDS)
6295 }
6296
6297 #[allow(unused_variables)]
6298 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6299 where
6300 E: serde::de::Error,
6301 {
6302 match value {
6303 "value" => Ok(GeneratedField::Value),
6304 "inclusive" => Ok(GeneratedField::Inclusive),
6305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6306 }
6307 }
6308 }
6309 deserializer.deserialize_identifier(GeneratedVisitor)
6310 }
6311 }
6312 struct GeneratedVisitor;
6313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6314 type Value = scan_range::Bound;
6315
6316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6317 formatter.write_str("struct batch_plan.ScanRange.Bound")
6318 }
6319
6320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<scan_range::Bound, V::Error>
6321 where
6322 V: serde::de::MapAccess<'de>,
6323 {
6324 let mut value__ = None;
6325 let mut inclusive__ = None;
6326 while let Some(k) = map_.next_key()? {
6327 match k {
6328 GeneratedField::Value => {
6329 if value__.is_some() {
6330 return Err(serde::de::Error::duplicate_field("value"));
6331 }
6332 value__ =
6333 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6334 .into_iter().map(|x| x.0).collect())
6335 ;
6336 }
6337 GeneratedField::Inclusive => {
6338 if inclusive__.is_some() {
6339 return Err(serde::de::Error::duplicate_field("inclusive"));
6340 }
6341 inclusive__ = Some(map_.next_value()?);
6342 }
6343 }
6344 }
6345 Ok(scan_range::Bound {
6346 value: value__.unwrap_or_default(),
6347 inclusive: inclusive__.unwrap_or_default(),
6348 })
6349 }
6350 }
6351 deserializer.deserialize_struct("batch_plan.ScanRange.Bound", FIELDS, GeneratedVisitor)
6352 }
6353}
6354impl serde::Serialize for SortAggNode {
6355 #[allow(deprecated)]
6356 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6357 where
6358 S: serde::Serializer,
6359 {
6360 use serde::ser::SerializeStruct;
6361 let mut len = 0;
6362 if !self.group_key.is_empty() {
6363 len += 1;
6364 }
6365 if !self.agg_calls.is_empty() {
6366 len += 1;
6367 }
6368 let mut struct_ser = serializer.serialize_struct("batch_plan.SortAggNode", len)?;
6369 if !self.group_key.is_empty() {
6370 struct_ser.serialize_field("groupKey", &self.group_key)?;
6371 }
6372 if !self.agg_calls.is_empty() {
6373 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6374 }
6375 struct_ser.end()
6376 }
6377}
6378impl<'de> serde::Deserialize<'de> for SortAggNode {
6379 #[allow(deprecated)]
6380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6381 where
6382 D: serde::Deserializer<'de>,
6383 {
6384 const FIELDS: &[&str] = &[
6385 "group_key",
6386 "groupKey",
6387 "agg_calls",
6388 "aggCalls",
6389 ];
6390
6391 #[allow(clippy::enum_variant_names)]
6392 enum GeneratedField {
6393 GroupKey,
6394 AggCalls,
6395 }
6396 impl<'de> serde::Deserialize<'de> for GeneratedField {
6397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6398 where
6399 D: serde::Deserializer<'de>,
6400 {
6401 struct GeneratedVisitor;
6402
6403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6404 type Value = GeneratedField;
6405
6406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6407 write!(formatter, "expected one of: {:?}", &FIELDS)
6408 }
6409
6410 #[allow(unused_variables)]
6411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6412 where
6413 E: serde::de::Error,
6414 {
6415 match value {
6416 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6417 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6418 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6419 }
6420 }
6421 }
6422 deserializer.deserialize_identifier(GeneratedVisitor)
6423 }
6424 }
6425 struct GeneratedVisitor;
6426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6427 type Value = SortAggNode;
6428
6429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6430 formatter.write_str("struct batch_plan.SortAggNode")
6431 }
6432
6433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortAggNode, V::Error>
6434 where
6435 V: serde::de::MapAccess<'de>,
6436 {
6437 let mut group_key__ = None;
6438 let mut agg_calls__ = None;
6439 while let Some(k) = map_.next_key()? {
6440 match k {
6441 GeneratedField::GroupKey => {
6442 if group_key__.is_some() {
6443 return Err(serde::de::Error::duplicate_field("groupKey"));
6444 }
6445 group_key__ = Some(map_.next_value()?);
6446 }
6447 GeneratedField::AggCalls => {
6448 if agg_calls__.is_some() {
6449 return Err(serde::de::Error::duplicate_field("aggCalls"));
6450 }
6451 agg_calls__ = Some(map_.next_value()?);
6452 }
6453 }
6454 }
6455 Ok(SortAggNode {
6456 group_key: group_key__.unwrap_or_default(),
6457 agg_calls: agg_calls__.unwrap_or_default(),
6458 })
6459 }
6460 }
6461 deserializer.deserialize_struct("batch_plan.SortAggNode", FIELDS, GeneratedVisitor)
6462 }
6463}
6464impl serde::Serialize for SortMergeJoinNode {
6465 #[allow(deprecated)]
6466 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6467 where
6468 S: serde::Serializer,
6469 {
6470 use serde::ser::SerializeStruct;
6471 let mut len = 0;
6472 if self.join_type != 0 {
6473 len += 1;
6474 }
6475 if !self.left_key.is_empty() {
6476 len += 1;
6477 }
6478 if !self.right_key.is_empty() {
6479 len += 1;
6480 }
6481 if self.direction != 0 {
6482 len += 1;
6483 }
6484 if !self.output_indices.is_empty() {
6485 len += 1;
6486 }
6487 let mut struct_ser = serializer.serialize_struct("batch_plan.SortMergeJoinNode", len)?;
6488 if self.join_type != 0 {
6489 let v = super::plan_common::JoinType::try_from(self.join_type)
6490 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6491 struct_ser.serialize_field("joinType", &v)?;
6492 }
6493 if !self.left_key.is_empty() {
6494 struct_ser.serialize_field("leftKey", &self.left_key)?;
6495 }
6496 if !self.right_key.is_empty() {
6497 struct_ser.serialize_field("rightKey", &self.right_key)?;
6498 }
6499 if self.direction != 0 {
6500 let v = super::common::Direction::try_from(self.direction)
6501 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
6502 struct_ser.serialize_field("direction", &v)?;
6503 }
6504 if !self.output_indices.is_empty() {
6505 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6506 }
6507 struct_ser.end()
6508 }
6509}
6510impl<'de> serde::Deserialize<'de> for SortMergeJoinNode {
6511 #[allow(deprecated)]
6512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6513 where
6514 D: serde::Deserializer<'de>,
6515 {
6516 const FIELDS: &[&str] = &[
6517 "join_type",
6518 "joinType",
6519 "left_key",
6520 "leftKey",
6521 "right_key",
6522 "rightKey",
6523 "direction",
6524 "output_indices",
6525 "outputIndices",
6526 ];
6527
6528 #[allow(clippy::enum_variant_names)]
6529 enum GeneratedField {
6530 JoinType,
6531 LeftKey,
6532 RightKey,
6533 Direction,
6534 OutputIndices,
6535 }
6536 impl<'de> serde::Deserialize<'de> for GeneratedField {
6537 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6538 where
6539 D: serde::Deserializer<'de>,
6540 {
6541 struct GeneratedVisitor;
6542
6543 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6544 type Value = GeneratedField;
6545
6546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6547 write!(formatter, "expected one of: {:?}", &FIELDS)
6548 }
6549
6550 #[allow(unused_variables)]
6551 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6552 where
6553 E: serde::de::Error,
6554 {
6555 match value {
6556 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6557 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6558 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6559 "direction" => Ok(GeneratedField::Direction),
6560 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6561 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6562 }
6563 }
6564 }
6565 deserializer.deserialize_identifier(GeneratedVisitor)
6566 }
6567 }
6568 struct GeneratedVisitor;
6569 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6570 type Value = SortMergeJoinNode;
6571
6572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6573 formatter.write_str("struct batch_plan.SortMergeJoinNode")
6574 }
6575
6576 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortMergeJoinNode, V::Error>
6577 where
6578 V: serde::de::MapAccess<'de>,
6579 {
6580 let mut join_type__ = None;
6581 let mut left_key__ = None;
6582 let mut right_key__ = None;
6583 let mut direction__ = None;
6584 let mut output_indices__ = None;
6585 while let Some(k) = map_.next_key()? {
6586 match k {
6587 GeneratedField::JoinType => {
6588 if join_type__.is_some() {
6589 return Err(serde::de::Error::duplicate_field("joinType"));
6590 }
6591 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6592 }
6593 GeneratedField::LeftKey => {
6594 if left_key__.is_some() {
6595 return Err(serde::de::Error::duplicate_field("leftKey"));
6596 }
6597 left_key__ =
6598 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6599 .into_iter().map(|x| x.0).collect())
6600 ;
6601 }
6602 GeneratedField::RightKey => {
6603 if right_key__.is_some() {
6604 return Err(serde::de::Error::duplicate_field("rightKey"));
6605 }
6606 right_key__ =
6607 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6608 .into_iter().map(|x| x.0).collect())
6609 ;
6610 }
6611 GeneratedField::Direction => {
6612 if direction__.is_some() {
6613 return Err(serde::de::Error::duplicate_field("direction"));
6614 }
6615 direction__ = Some(map_.next_value::<super::common::Direction>()? as i32);
6616 }
6617 GeneratedField::OutputIndices => {
6618 if output_indices__.is_some() {
6619 return Err(serde::de::Error::duplicate_field("outputIndices"));
6620 }
6621 output_indices__ =
6622 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6623 .into_iter().map(|x| x.0).collect())
6624 ;
6625 }
6626 }
6627 }
6628 Ok(SortMergeJoinNode {
6629 join_type: join_type__.unwrap_or_default(),
6630 left_key: left_key__.unwrap_or_default(),
6631 right_key: right_key__.unwrap_or_default(),
6632 direction: direction__.unwrap_or_default(),
6633 output_indices: output_indices__.unwrap_or_default(),
6634 })
6635 }
6636 }
6637 deserializer.deserialize_struct("batch_plan.SortMergeJoinNode", FIELDS, GeneratedVisitor)
6638 }
6639}
6640impl serde::Serialize for SortNode {
6641 #[allow(deprecated)]
6642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6643 where
6644 S: serde::Serializer,
6645 {
6646 use serde::ser::SerializeStruct;
6647 let mut len = 0;
6648 if !self.column_orders.is_empty() {
6649 len += 1;
6650 }
6651 let mut struct_ser = serializer.serialize_struct("batch_plan.SortNode", len)?;
6652 if !self.column_orders.is_empty() {
6653 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6654 }
6655 struct_ser.end()
6656 }
6657}
6658impl<'de> serde::Deserialize<'de> for SortNode {
6659 #[allow(deprecated)]
6660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6661 where
6662 D: serde::Deserializer<'de>,
6663 {
6664 const FIELDS: &[&str] = &[
6665 "column_orders",
6666 "columnOrders",
6667 ];
6668
6669 #[allow(clippy::enum_variant_names)]
6670 enum GeneratedField {
6671 ColumnOrders,
6672 }
6673 impl<'de> serde::Deserialize<'de> for GeneratedField {
6674 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6675 where
6676 D: serde::Deserializer<'de>,
6677 {
6678 struct GeneratedVisitor;
6679
6680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6681 type Value = GeneratedField;
6682
6683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6684 write!(formatter, "expected one of: {:?}", &FIELDS)
6685 }
6686
6687 #[allow(unused_variables)]
6688 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6689 where
6690 E: serde::de::Error,
6691 {
6692 match value {
6693 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6695 }
6696 }
6697 }
6698 deserializer.deserialize_identifier(GeneratedVisitor)
6699 }
6700 }
6701 struct GeneratedVisitor;
6702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6703 type Value = SortNode;
6704
6705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6706 formatter.write_str("struct batch_plan.SortNode")
6707 }
6708
6709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
6710 where
6711 V: serde::de::MapAccess<'de>,
6712 {
6713 let mut column_orders__ = None;
6714 while let Some(k) = map_.next_key()? {
6715 match k {
6716 GeneratedField::ColumnOrders => {
6717 if column_orders__.is_some() {
6718 return Err(serde::de::Error::duplicate_field("columnOrders"));
6719 }
6720 column_orders__ = Some(map_.next_value()?);
6721 }
6722 }
6723 }
6724 Ok(SortNode {
6725 column_orders: column_orders__.unwrap_or_default(),
6726 })
6727 }
6728 }
6729 deserializer.deserialize_struct("batch_plan.SortNode", FIELDS, GeneratedVisitor)
6730 }
6731}
6732impl serde::Serialize for SortOverWindowNode {
6733 #[allow(deprecated)]
6734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6735 where
6736 S: serde::Serializer,
6737 {
6738 use serde::ser::SerializeStruct;
6739 let mut len = 0;
6740 if !self.calls.is_empty() {
6741 len += 1;
6742 }
6743 if !self.partition_by.is_empty() {
6744 len += 1;
6745 }
6746 if !self.order_by.is_empty() {
6747 len += 1;
6748 }
6749 let mut struct_ser = serializer.serialize_struct("batch_plan.SortOverWindowNode", len)?;
6750 if !self.calls.is_empty() {
6751 struct_ser.serialize_field("calls", &self.calls)?;
6752 }
6753 if !self.partition_by.is_empty() {
6754 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
6755 }
6756 if !self.order_by.is_empty() {
6757 struct_ser.serialize_field("orderBy", &self.order_by)?;
6758 }
6759 struct_ser.end()
6760 }
6761}
6762impl<'de> serde::Deserialize<'de> for SortOverWindowNode {
6763 #[allow(deprecated)]
6764 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6765 where
6766 D: serde::Deserializer<'de>,
6767 {
6768 const FIELDS: &[&str] = &[
6769 "calls",
6770 "partition_by",
6771 "partitionBy",
6772 "order_by",
6773 "orderBy",
6774 ];
6775
6776 #[allow(clippy::enum_variant_names)]
6777 enum GeneratedField {
6778 Calls,
6779 PartitionBy,
6780 OrderBy,
6781 }
6782 impl<'de> serde::Deserialize<'de> for GeneratedField {
6783 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6784 where
6785 D: serde::Deserializer<'de>,
6786 {
6787 struct GeneratedVisitor;
6788
6789 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6790 type Value = GeneratedField;
6791
6792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6793 write!(formatter, "expected one of: {:?}", &FIELDS)
6794 }
6795
6796 #[allow(unused_variables)]
6797 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6798 where
6799 E: serde::de::Error,
6800 {
6801 match value {
6802 "calls" => Ok(GeneratedField::Calls),
6803 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
6804 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
6805 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6806 }
6807 }
6808 }
6809 deserializer.deserialize_identifier(GeneratedVisitor)
6810 }
6811 }
6812 struct GeneratedVisitor;
6813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6814 type Value = SortOverWindowNode;
6815
6816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6817 formatter.write_str("struct batch_plan.SortOverWindowNode")
6818 }
6819
6820 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortOverWindowNode, V::Error>
6821 where
6822 V: serde::de::MapAccess<'de>,
6823 {
6824 let mut calls__ = None;
6825 let mut partition_by__ = None;
6826 let mut order_by__ = None;
6827 while let Some(k) = map_.next_key()? {
6828 match k {
6829 GeneratedField::Calls => {
6830 if calls__.is_some() {
6831 return Err(serde::de::Error::duplicate_field("calls"));
6832 }
6833 calls__ = Some(map_.next_value()?);
6834 }
6835 GeneratedField::PartitionBy => {
6836 if partition_by__.is_some() {
6837 return Err(serde::de::Error::duplicate_field("partitionBy"));
6838 }
6839 partition_by__ =
6840 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6841 .into_iter().map(|x| x.0).collect())
6842 ;
6843 }
6844 GeneratedField::OrderBy => {
6845 if order_by__.is_some() {
6846 return Err(serde::de::Error::duplicate_field("orderBy"));
6847 }
6848 order_by__ = Some(map_.next_value()?);
6849 }
6850 }
6851 }
6852 Ok(SortOverWindowNode {
6853 calls: calls__.unwrap_or_default(),
6854 partition_by: partition_by__.unwrap_or_default(),
6855 order_by: order_by__.unwrap_or_default(),
6856 })
6857 }
6858 }
6859 deserializer.deserialize_struct("batch_plan.SortOverWindowNode", FIELDS, GeneratedVisitor)
6860 }
6861}
6862impl serde::Serialize for SourceNode {
6863 #[allow(deprecated)]
6864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6865 where
6866 S: serde::Serializer,
6867 {
6868 use serde::ser::SerializeStruct;
6869 let mut len = 0;
6870 if self.source_id != 0 {
6871 len += 1;
6872 }
6873 if !self.columns.is_empty() {
6874 len += 1;
6875 }
6876 if !self.with_properties.is_empty() {
6877 len += 1;
6878 }
6879 if !self.split.is_empty() {
6880 len += 1;
6881 }
6882 if self.info.is_some() {
6883 len += 1;
6884 }
6885 if !self.secret_refs.is_empty() {
6886 len += 1;
6887 }
6888 let mut struct_ser = serializer.serialize_struct("batch_plan.SourceNode", len)?;
6889 if self.source_id != 0 {
6890 struct_ser.serialize_field("sourceId", &self.source_id)?;
6891 }
6892 if !self.columns.is_empty() {
6893 struct_ser.serialize_field("columns", &self.columns)?;
6894 }
6895 if !self.with_properties.is_empty() {
6896 struct_ser.serialize_field("withProperties", &self.with_properties)?;
6897 }
6898 if !self.split.is_empty() {
6899 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6900 }
6901 if let Some(v) = self.info.as_ref() {
6902 struct_ser.serialize_field("info", v)?;
6903 }
6904 if !self.secret_refs.is_empty() {
6905 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
6906 }
6907 struct_ser.end()
6908 }
6909}
6910impl<'de> serde::Deserialize<'de> for SourceNode {
6911 #[allow(deprecated)]
6912 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6913 where
6914 D: serde::Deserializer<'de>,
6915 {
6916 const FIELDS: &[&str] = &[
6917 "source_id",
6918 "sourceId",
6919 "columns",
6920 "with_properties",
6921 "withProperties",
6922 "split",
6923 "info",
6924 "secret_refs",
6925 "secretRefs",
6926 ];
6927
6928 #[allow(clippy::enum_variant_names)]
6929 enum GeneratedField {
6930 SourceId,
6931 Columns,
6932 WithProperties,
6933 Split,
6934 Info,
6935 SecretRefs,
6936 }
6937 impl<'de> serde::Deserialize<'de> for GeneratedField {
6938 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6939 where
6940 D: serde::Deserializer<'de>,
6941 {
6942 struct GeneratedVisitor;
6943
6944 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6945 type Value = GeneratedField;
6946
6947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6948 write!(formatter, "expected one of: {:?}", &FIELDS)
6949 }
6950
6951 #[allow(unused_variables)]
6952 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6953 where
6954 E: serde::de::Error,
6955 {
6956 match value {
6957 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
6958 "columns" => Ok(GeneratedField::Columns),
6959 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
6960 "split" => Ok(GeneratedField::Split),
6961 "info" => Ok(GeneratedField::Info),
6962 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
6963 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6964 }
6965 }
6966 }
6967 deserializer.deserialize_identifier(GeneratedVisitor)
6968 }
6969 }
6970 struct GeneratedVisitor;
6971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6972 type Value = SourceNode;
6973
6974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6975 formatter.write_str("struct batch_plan.SourceNode")
6976 }
6977
6978 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
6979 where
6980 V: serde::de::MapAccess<'de>,
6981 {
6982 let mut source_id__ = None;
6983 let mut columns__ = None;
6984 let mut with_properties__ = None;
6985 let mut split__ = None;
6986 let mut info__ = None;
6987 let mut secret_refs__ = None;
6988 while let Some(k) = map_.next_key()? {
6989 match k {
6990 GeneratedField::SourceId => {
6991 if source_id__.is_some() {
6992 return Err(serde::de::Error::duplicate_field("sourceId"));
6993 }
6994 source_id__ =
6995 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6996 ;
6997 }
6998 GeneratedField::Columns => {
6999 if columns__.is_some() {
7000 return Err(serde::de::Error::duplicate_field("columns"));
7001 }
7002 columns__ = Some(map_.next_value()?);
7003 }
7004 GeneratedField::WithProperties => {
7005 if with_properties__.is_some() {
7006 return Err(serde::de::Error::duplicate_field("withProperties"));
7007 }
7008 with_properties__ = Some(
7009 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7010 );
7011 }
7012 GeneratedField::Split => {
7013 if split__.is_some() {
7014 return Err(serde::de::Error::duplicate_field("split"));
7015 }
7016 split__ =
7017 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7018 .into_iter().map(|x| x.0).collect())
7019 ;
7020 }
7021 GeneratedField::Info => {
7022 if info__.is_some() {
7023 return Err(serde::de::Error::duplicate_field("info"));
7024 }
7025 info__ = map_.next_value()?;
7026 }
7027 GeneratedField::SecretRefs => {
7028 if secret_refs__.is_some() {
7029 return Err(serde::de::Error::duplicate_field("secretRefs"));
7030 }
7031 secret_refs__ = Some(
7032 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7033 );
7034 }
7035 }
7036 }
7037 Ok(SourceNode {
7038 source_id: source_id__.unwrap_or_default(),
7039 columns: columns__.unwrap_or_default(),
7040 with_properties: with_properties__.unwrap_or_default(),
7041 split: split__.unwrap_or_default(),
7042 info: info__,
7043 secret_refs: secret_refs__.unwrap_or_default(),
7044 })
7045 }
7046 }
7047 deserializer.deserialize_struct("batch_plan.SourceNode", FIELDS, GeneratedVisitor)
7048 }
7049}
7050impl serde::Serialize for SysRowSeqScanNode {
7051 #[allow(deprecated)]
7052 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7053 where
7054 S: serde::Serializer,
7055 {
7056 use serde::ser::SerializeStruct;
7057 let mut len = 0;
7058 if self.table_id != 0 {
7059 len += 1;
7060 }
7061 if !self.column_descs.is_empty() {
7062 len += 1;
7063 }
7064 let mut struct_ser = serializer.serialize_struct("batch_plan.SysRowSeqScanNode", len)?;
7065 if self.table_id != 0 {
7066 struct_ser.serialize_field("tableId", &self.table_id)?;
7067 }
7068 if !self.column_descs.is_empty() {
7069 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
7070 }
7071 struct_ser.end()
7072 }
7073}
7074impl<'de> serde::Deserialize<'de> for SysRowSeqScanNode {
7075 #[allow(deprecated)]
7076 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7077 where
7078 D: serde::Deserializer<'de>,
7079 {
7080 const FIELDS: &[&str] = &[
7081 "table_id",
7082 "tableId",
7083 "column_descs",
7084 "columnDescs",
7085 ];
7086
7087 #[allow(clippy::enum_variant_names)]
7088 enum GeneratedField {
7089 TableId,
7090 ColumnDescs,
7091 }
7092 impl<'de> serde::Deserialize<'de> for GeneratedField {
7093 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7094 where
7095 D: serde::Deserializer<'de>,
7096 {
7097 struct GeneratedVisitor;
7098
7099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7100 type Value = GeneratedField;
7101
7102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7103 write!(formatter, "expected one of: {:?}", &FIELDS)
7104 }
7105
7106 #[allow(unused_variables)]
7107 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7108 where
7109 E: serde::de::Error,
7110 {
7111 match value {
7112 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7113 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
7114 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7115 }
7116 }
7117 }
7118 deserializer.deserialize_identifier(GeneratedVisitor)
7119 }
7120 }
7121 struct GeneratedVisitor;
7122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7123 type Value = SysRowSeqScanNode;
7124
7125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7126 formatter.write_str("struct batch_plan.SysRowSeqScanNode")
7127 }
7128
7129 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SysRowSeqScanNode, V::Error>
7130 where
7131 V: serde::de::MapAccess<'de>,
7132 {
7133 let mut table_id__ = None;
7134 let mut column_descs__ = None;
7135 while let Some(k) = map_.next_key()? {
7136 match k {
7137 GeneratedField::TableId => {
7138 if table_id__.is_some() {
7139 return Err(serde::de::Error::duplicate_field("tableId"));
7140 }
7141 table_id__ =
7142 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7143 ;
7144 }
7145 GeneratedField::ColumnDescs => {
7146 if column_descs__.is_some() {
7147 return Err(serde::de::Error::duplicate_field("columnDescs"));
7148 }
7149 column_descs__ = Some(map_.next_value()?);
7150 }
7151 }
7152 }
7153 Ok(SysRowSeqScanNode {
7154 table_id: table_id__.unwrap_or_default(),
7155 column_descs: column_descs__.unwrap_or_default(),
7156 })
7157 }
7158 }
7159 deserializer.deserialize_struct("batch_plan.SysRowSeqScanNode", FIELDS, GeneratedVisitor)
7160 }
7161}
7162impl serde::Serialize for TableFunctionNode {
7163 #[allow(deprecated)]
7164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7165 where
7166 S: serde::Serializer,
7167 {
7168 use serde::ser::SerializeStruct;
7169 let mut len = 0;
7170 if self.table_function.is_some() {
7171 len += 1;
7172 }
7173 let mut struct_ser = serializer.serialize_struct("batch_plan.TableFunctionNode", len)?;
7174 if let Some(v) = self.table_function.as_ref() {
7175 struct_ser.serialize_field("tableFunction", v)?;
7176 }
7177 struct_ser.end()
7178 }
7179}
7180impl<'de> serde::Deserialize<'de> for TableFunctionNode {
7181 #[allow(deprecated)]
7182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7183 where
7184 D: serde::Deserializer<'de>,
7185 {
7186 const FIELDS: &[&str] = &[
7187 "table_function",
7188 "tableFunction",
7189 ];
7190
7191 #[allow(clippy::enum_variant_names)]
7192 enum GeneratedField {
7193 TableFunction,
7194 }
7195 impl<'de> serde::Deserialize<'de> for GeneratedField {
7196 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7197 where
7198 D: serde::Deserializer<'de>,
7199 {
7200 struct GeneratedVisitor;
7201
7202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7203 type Value = GeneratedField;
7204
7205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7206 write!(formatter, "expected one of: {:?}", &FIELDS)
7207 }
7208
7209 #[allow(unused_variables)]
7210 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7211 where
7212 E: serde::de::Error,
7213 {
7214 match value {
7215 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
7216 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7217 }
7218 }
7219 }
7220 deserializer.deserialize_identifier(GeneratedVisitor)
7221 }
7222 }
7223 struct GeneratedVisitor;
7224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7225 type Value = TableFunctionNode;
7226
7227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7228 formatter.write_str("struct batch_plan.TableFunctionNode")
7229 }
7230
7231 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunctionNode, V::Error>
7232 where
7233 V: serde::de::MapAccess<'de>,
7234 {
7235 let mut table_function__ = None;
7236 while let Some(k) = map_.next_key()? {
7237 match k {
7238 GeneratedField::TableFunction => {
7239 if table_function__.is_some() {
7240 return Err(serde::de::Error::duplicate_field("tableFunction"));
7241 }
7242 table_function__ = map_.next_value()?;
7243 }
7244 }
7245 }
7246 Ok(TableFunctionNode {
7247 table_function: table_function__,
7248 })
7249 }
7250 }
7251 deserializer.deserialize_struct("batch_plan.TableFunctionNode", FIELDS, GeneratedVisitor)
7252 }
7253}
7254impl serde::Serialize for TaskId {
7255 #[allow(deprecated)]
7256 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7257 where
7258 S: serde::Serializer,
7259 {
7260 use serde::ser::SerializeStruct;
7261 let mut len = 0;
7262 if !self.query_id.is_empty() {
7263 len += 1;
7264 }
7265 if self.stage_id != 0 {
7266 len += 1;
7267 }
7268 if self.task_id != 0 {
7269 len += 1;
7270 }
7271 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskId", len)?;
7272 if !self.query_id.is_empty() {
7273 struct_ser.serialize_field("queryId", &self.query_id)?;
7274 }
7275 if self.stage_id != 0 {
7276 struct_ser.serialize_field("stageId", &self.stage_id)?;
7277 }
7278 if self.task_id != 0 {
7279 #[allow(clippy::needless_borrow)]
7280 #[allow(clippy::needless_borrows_for_generic_args)]
7281 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7282 }
7283 struct_ser.end()
7284 }
7285}
7286impl<'de> serde::Deserialize<'de> for TaskId {
7287 #[allow(deprecated)]
7288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7289 where
7290 D: serde::Deserializer<'de>,
7291 {
7292 const FIELDS: &[&str] = &[
7293 "query_id",
7294 "queryId",
7295 "stage_id",
7296 "stageId",
7297 "task_id",
7298 "taskId",
7299 ];
7300
7301 #[allow(clippy::enum_variant_names)]
7302 enum GeneratedField {
7303 QueryId,
7304 StageId,
7305 TaskId,
7306 }
7307 impl<'de> serde::Deserialize<'de> for GeneratedField {
7308 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7309 where
7310 D: serde::Deserializer<'de>,
7311 {
7312 struct GeneratedVisitor;
7313
7314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7315 type Value = GeneratedField;
7316
7317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7318 write!(formatter, "expected one of: {:?}", &FIELDS)
7319 }
7320
7321 #[allow(unused_variables)]
7322 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7323 where
7324 E: serde::de::Error,
7325 {
7326 match value {
7327 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
7328 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
7329 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7330 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7331 }
7332 }
7333 }
7334 deserializer.deserialize_identifier(GeneratedVisitor)
7335 }
7336 }
7337 struct GeneratedVisitor;
7338 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7339 type Value = TaskId;
7340
7341 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7342 formatter.write_str("struct batch_plan.TaskId")
7343 }
7344
7345 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
7346 where
7347 V: serde::de::MapAccess<'de>,
7348 {
7349 let mut query_id__ = None;
7350 let mut stage_id__ = None;
7351 let mut task_id__ = None;
7352 while let Some(k) = map_.next_key()? {
7353 match k {
7354 GeneratedField::QueryId => {
7355 if query_id__.is_some() {
7356 return Err(serde::de::Error::duplicate_field("queryId"));
7357 }
7358 query_id__ = Some(map_.next_value()?);
7359 }
7360 GeneratedField::StageId => {
7361 if stage_id__.is_some() {
7362 return Err(serde::de::Error::duplicate_field("stageId"));
7363 }
7364 stage_id__ =
7365 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7366 ;
7367 }
7368 GeneratedField::TaskId => {
7369 if task_id__.is_some() {
7370 return Err(serde::de::Error::duplicate_field("taskId"));
7371 }
7372 task_id__ =
7373 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7374 ;
7375 }
7376 }
7377 }
7378 Ok(TaskId {
7379 query_id: query_id__.unwrap_or_default(),
7380 stage_id: stage_id__.unwrap_or_default(),
7381 task_id: task_id__.unwrap_or_default(),
7382 })
7383 }
7384 }
7385 deserializer.deserialize_struct("batch_plan.TaskId", FIELDS, GeneratedVisitor)
7386 }
7387}
7388impl serde::Serialize for TaskOutputId {
7389 #[allow(deprecated)]
7390 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7391 where
7392 S: serde::Serializer,
7393 {
7394 use serde::ser::SerializeStruct;
7395 let mut len = 0;
7396 if self.task_id.is_some() {
7397 len += 1;
7398 }
7399 if self.output_id != 0 {
7400 len += 1;
7401 }
7402 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskOutputId", len)?;
7403 if let Some(v) = self.task_id.as_ref() {
7404 struct_ser.serialize_field("taskId", v)?;
7405 }
7406 if self.output_id != 0 {
7407 #[allow(clippy::needless_borrow)]
7408 #[allow(clippy::needless_borrows_for_generic_args)]
7409 struct_ser.serialize_field("outputId", ToString::to_string(&self.output_id).as_str())?;
7410 }
7411 struct_ser.end()
7412 }
7413}
7414impl<'de> serde::Deserialize<'de> for TaskOutputId {
7415 #[allow(deprecated)]
7416 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7417 where
7418 D: serde::Deserializer<'de>,
7419 {
7420 const FIELDS: &[&str] = &[
7421 "task_id",
7422 "taskId",
7423 "output_id",
7424 "outputId",
7425 ];
7426
7427 #[allow(clippy::enum_variant_names)]
7428 enum GeneratedField {
7429 TaskId,
7430 OutputId,
7431 }
7432 impl<'de> serde::Deserialize<'de> for GeneratedField {
7433 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7434 where
7435 D: serde::Deserializer<'de>,
7436 {
7437 struct GeneratedVisitor;
7438
7439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7440 type Value = GeneratedField;
7441
7442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7443 write!(formatter, "expected one of: {:?}", &FIELDS)
7444 }
7445
7446 #[allow(unused_variables)]
7447 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7448 where
7449 E: serde::de::Error,
7450 {
7451 match value {
7452 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7453 "outputId" | "output_id" => Ok(GeneratedField::OutputId),
7454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7455 }
7456 }
7457 }
7458 deserializer.deserialize_identifier(GeneratedVisitor)
7459 }
7460 }
7461 struct GeneratedVisitor;
7462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7463 type Value = TaskOutputId;
7464
7465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7466 formatter.write_str("struct batch_plan.TaskOutputId")
7467 }
7468
7469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskOutputId, V::Error>
7470 where
7471 V: serde::de::MapAccess<'de>,
7472 {
7473 let mut task_id__ = None;
7474 let mut output_id__ = None;
7475 while let Some(k) = map_.next_key()? {
7476 match k {
7477 GeneratedField::TaskId => {
7478 if task_id__.is_some() {
7479 return Err(serde::de::Error::duplicate_field("taskId"));
7480 }
7481 task_id__ = map_.next_value()?;
7482 }
7483 GeneratedField::OutputId => {
7484 if output_id__.is_some() {
7485 return Err(serde::de::Error::duplicate_field("outputId"));
7486 }
7487 output_id__ =
7488 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7489 ;
7490 }
7491 }
7492 }
7493 Ok(TaskOutputId {
7494 task_id: task_id__,
7495 output_id: output_id__.unwrap_or_default(),
7496 })
7497 }
7498 }
7499 deserializer.deserialize_struct("batch_plan.TaskOutputId", FIELDS, GeneratedVisitor)
7500 }
7501}
7502impl serde::Serialize for TopNNode {
7503 #[allow(deprecated)]
7504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7505 where
7506 S: serde::Serializer,
7507 {
7508 use serde::ser::SerializeStruct;
7509 let mut len = 0;
7510 if !self.column_orders.is_empty() {
7511 len += 1;
7512 }
7513 if self.limit != 0 {
7514 len += 1;
7515 }
7516 if self.offset != 0 {
7517 len += 1;
7518 }
7519 if self.with_ties {
7520 len += 1;
7521 }
7522 let mut struct_ser = serializer.serialize_struct("batch_plan.TopNNode", len)?;
7523 if !self.column_orders.is_empty() {
7524 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7525 }
7526 if self.limit != 0 {
7527 #[allow(clippy::needless_borrow)]
7528 #[allow(clippy::needless_borrows_for_generic_args)]
7529 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
7530 }
7531 if self.offset != 0 {
7532 #[allow(clippy::needless_borrow)]
7533 #[allow(clippy::needless_borrows_for_generic_args)]
7534 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
7535 }
7536 if self.with_ties {
7537 struct_ser.serialize_field("withTies", &self.with_ties)?;
7538 }
7539 struct_ser.end()
7540 }
7541}
7542impl<'de> serde::Deserialize<'de> for TopNNode {
7543 #[allow(deprecated)]
7544 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7545 where
7546 D: serde::Deserializer<'de>,
7547 {
7548 const FIELDS: &[&str] = &[
7549 "column_orders",
7550 "columnOrders",
7551 "limit",
7552 "offset",
7553 "with_ties",
7554 "withTies",
7555 ];
7556
7557 #[allow(clippy::enum_variant_names)]
7558 enum GeneratedField {
7559 ColumnOrders,
7560 Limit,
7561 Offset,
7562 WithTies,
7563 }
7564 impl<'de> serde::Deserialize<'de> for GeneratedField {
7565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7566 where
7567 D: serde::Deserializer<'de>,
7568 {
7569 struct GeneratedVisitor;
7570
7571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7572 type Value = GeneratedField;
7573
7574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7575 write!(formatter, "expected one of: {:?}", &FIELDS)
7576 }
7577
7578 #[allow(unused_variables)]
7579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7580 where
7581 E: serde::de::Error,
7582 {
7583 match value {
7584 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7585 "limit" => Ok(GeneratedField::Limit),
7586 "offset" => Ok(GeneratedField::Offset),
7587 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
7588 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7589 }
7590 }
7591 }
7592 deserializer.deserialize_identifier(GeneratedVisitor)
7593 }
7594 }
7595 struct GeneratedVisitor;
7596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7597 type Value = TopNNode;
7598
7599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7600 formatter.write_str("struct batch_plan.TopNNode")
7601 }
7602
7603 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
7604 where
7605 V: serde::de::MapAccess<'de>,
7606 {
7607 let mut column_orders__ = None;
7608 let mut limit__ = None;
7609 let mut offset__ = None;
7610 let mut with_ties__ = None;
7611 while let Some(k) = map_.next_key()? {
7612 match k {
7613 GeneratedField::ColumnOrders => {
7614 if column_orders__.is_some() {
7615 return Err(serde::de::Error::duplicate_field("columnOrders"));
7616 }
7617 column_orders__ = Some(map_.next_value()?);
7618 }
7619 GeneratedField::Limit => {
7620 if limit__.is_some() {
7621 return Err(serde::de::Error::duplicate_field("limit"));
7622 }
7623 limit__ =
7624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7625 ;
7626 }
7627 GeneratedField::Offset => {
7628 if offset__.is_some() {
7629 return Err(serde::de::Error::duplicate_field("offset"));
7630 }
7631 offset__ =
7632 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7633 ;
7634 }
7635 GeneratedField::WithTies => {
7636 if with_ties__.is_some() {
7637 return Err(serde::de::Error::duplicate_field("withTies"));
7638 }
7639 with_ties__ = Some(map_.next_value()?);
7640 }
7641 }
7642 }
7643 Ok(TopNNode {
7644 column_orders: column_orders__.unwrap_or_default(),
7645 limit: limit__.unwrap_or_default(),
7646 offset: offset__.unwrap_or_default(),
7647 with_ties: with_ties__.unwrap_or_default(),
7648 })
7649 }
7650 }
7651 deserializer.deserialize_struct("batch_plan.TopNNode", FIELDS, GeneratedVisitor)
7652 }
7653}
7654impl serde::Serialize for UnionNode {
7655 #[allow(deprecated)]
7656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7657 where
7658 S: serde::Serializer,
7659 {
7660 use serde::ser::SerializeStruct;
7661 let len = 0;
7662 let struct_ser = serializer.serialize_struct("batch_plan.UnionNode", len)?;
7663 struct_ser.end()
7664 }
7665}
7666impl<'de> serde::Deserialize<'de> for UnionNode {
7667 #[allow(deprecated)]
7668 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7669 where
7670 D: serde::Deserializer<'de>,
7671 {
7672 const FIELDS: &[&str] = &[
7673 ];
7674
7675 #[allow(clippy::enum_variant_names)]
7676 enum GeneratedField {
7677 }
7678 impl<'de> serde::Deserialize<'de> for GeneratedField {
7679 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7680 where
7681 D: serde::Deserializer<'de>,
7682 {
7683 struct GeneratedVisitor;
7684
7685 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7686 type Value = GeneratedField;
7687
7688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7689 write!(formatter, "expected one of: {:?}", &FIELDS)
7690 }
7691
7692 #[allow(unused_variables)]
7693 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7694 where
7695 E: serde::de::Error,
7696 {
7697 Err(serde::de::Error::unknown_field(value, FIELDS))
7698 }
7699 }
7700 deserializer.deserialize_identifier(GeneratedVisitor)
7701 }
7702 }
7703 struct GeneratedVisitor;
7704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7705 type Value = UnionNode;
7706
7707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7708 formatter.write_str("struct batch_plan.UnionNode")
7709 }
7710
7711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
7712 where
7713 V: serde::de::MapAccess<'de>,
7714 {
7715 while map_.next_key::<GeneratedField>()?.is_some() {
7716 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7717 }
7718 Ok(UnionNode {
7719 })
7720 }
7721 }
7722 deserializer.deserialize_struct("batch_plan.UnionNode", FIELDS, GeneratedVisitor)
7723 }
7724}
7725impl serde::Serialize for UpdateNode {
7726 #[allow(deprecated)]
7727 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7728 where
7729 S: serde::Serializer,
7730 {
7731 use serde::ser::SerializeStruct;
7732 let mut len = 0;
7733 if self.table_id != 0 {
7734 len += 1;
7735 }
7736 if self.table_version_id != 0 {
7737 len += 1;
7738 }
7739 if !self.old_exprs.is_empty() {
7740 len += 1;
7741 }
7742 if !self.new_exprs.is_empty() {
7743 len += 1;
7744 }
7745 if self.returning {
7746 len += 1;
7747 }
7748 if self.session_id != 0 {
7749 len += 1;
7750 }
7751 let mut struct_ser = serializer.serialize_struct("batch_plan.UpdateNode", len)?;
7752 if self.table_id != 0 {
7753 struct_ser.serialize_field("tableId", &self.table_id)?;
7754 }
7755 if self.table_version_id != 0 {
7756 #[allow(clippy::needless_borrow)]
7757 #[allow(clippy::needless_borrows_for_generic_args)]
7758 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
7759 }
7760 if !self.old_exprs.is_empty() {
7761 struct_ser.serialize_field("oldExprs", &self.old_exprs)?;
7762 }
7763 if !self.new_exprs.is_empty() {
7764 struct_ser.serialize_field("newExprs", &self.new_exprs)?;
7765 }
7766 if self.returning {
7767 struct_ser.serialize_field("returning", &self.returning)?;
7768 }
7769 if self.session_id != 0 {
7770 struct_ser.serialize_field("sessionId", &self.session_id)?;
7771 }
7772 struct_ser.end()
7773 }
7774}
7775impl<'de> serde::Deserialize<'de> for UpdateNode {
7776 #[allow(deprecated)]
7777 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7778 where
7779 D: serde::Deserializer<'de>,
7780 {
7781 const FIELDS: &[&str] = &[
7782 "table_id",
7783 "tableId",
7784 "table_version_id",
7785 "tableVersionId",
7786 "old_exprs",
7787 "oldExprs",
7788 "new_exprs",
7789 "newExprs",
7790 "returning",
7791 "session_id",
7792 "sessionId",
7793 ];
7794
7795 #[allow(clippy::enum_variant_names)]
7796 enum GeneratedField {
7797 TableId,
7798 TableVersionId,
7799 OldExprs,
7800 NewExprs,
7801 Returning,
7802 SessionId,
7803 }
7804 impl<'de> serde::Deserialize<'de> for GeneratedField {
7805 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7806 where
7807 D: serde::Deserializer<'de>,
7808 {
7809 struct GeneratedVisitor;
7810
7811 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7812 type Value = GeneratedField;
7813
7814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7815 write!(formatter, "expected one of: {:?}", &FIELDS)
7816 }
7817
7818 #[allow(unused_variables)]
7819 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7820 where
7821 E: serde::de::Error,
7822 {
7823 match value {
7824 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7825 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
7826 "oldExprs" | "old_exprs" => Ok(GeneratedField::OldExprs),
7827 "newExprs" | "new_exprs" => Ok(GeneratedField::NewExprs),
7828 "returning" => Ok(GeneratedField::Returning),
7829 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
7830 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7831 }
7832 }
7833 }
7834 deserializer.deserialize_identifier(GeneratedVisitor)
7835 }
7836 }
7837 struct GeneratedVisitor;
7838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7839 type Value = UpdateNode;
7840
7841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7842 formatter.write_str("struct batch_plan.UpdateNode")
7843 }
7844
7845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateNode, V::Error>
7846 where
7847 V: serde::de::MapAccess<'de>,
7848 {
7849 let mut table_id__ = None;
7850 let mut table_version_id__ = None;
7851 let mut old_exprs__ = None;
7852 let mut new_exprs__ = None;
7853 let mut returning__ = None;
7854 let mut session_id__ = None;
7855 while let Some(k) = map_.next_key()? {
7856 match k {
7857 GeneratedField::TableId => {
7858 if table_id__.is_some() {
7859 return Err(serde::de::Error::duplicate_field("tableId"));
7860 }
7861 table_id__ =
7862 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7863 ;
7864 }
7865 GeneratedField::TableVersionId => {
7866 if table_version_id__.is_some() {
7867 return Err(serde::de::Error::duplicate_field("tableVersionId"));
7868 }
7869 table_version_id__ =
7870 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7871 ;
7872 }
7873 GeneratedField::OldExprs => {
7874 if old_exprs__.is_some() {
7875 return Err(serde::de::Error::duplicate_field("oldExprs"));
7876 }
7877 old_exprs__ = Some(map_.next_value()?);
7878 }
7879 GeneratedField::NewExprs => {
7880 if new_exprs__.is_some() {
7881 return Err(serde::de::Error::duplicate_field("newExprs"));
7882 }
7883 new_exprs__ = Some(map_.next_value()?);
7884 }
7885 GeneratedField::Returning => {
7886 if returning__.is_some() {
7887 return Err(serde::de::Error::duplicate_field("returning"));
7888 }
7889 returning__ = Some(map_.next_value()?);
7890 }
7891 GeneratedField::SessionId => {
7892 if session_id__.is_some() {
7893 return Err(serde::de::Error::duplicate_field("sessionId"));
7894 }
7895 session_id__ =
7896 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7897 ;
7898 }
7899 }
7900 }
7901 Ok(UpdateNode {
7902 table_id: table_id__.unwrap_or_default(),
7903 table_version_id: table_version_id__.unwrap_or_default(),
7904 old_exprs: old_exprs__.unwrap_or_default(),
7905 new_exprs: new_exprs__.unwrap_or_default(),
7906 returning: returning__.unwrap_or_default(),
7907 session_id: session_id__.unwrap_or_default(),
7908 })
7909 }
7910 }
7911 deserializer.deserialize_struct("batch_plan.UpdateNode", FIELDS, GeneratedVisitor)
7912 }
7913}
7914impl serde::Serialize for ValuesNode {
7915 #[allow(deprecated)]
7916 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7917 where
7918 S: serde::Serializer,
7919 {
7920 use serde::ser::SerializeStruct;
7921 let mut len = 0;
7922 if !self.tuples.is_empty() {
7923 len += 1;
7924 }
7925 if !self.fields.is_empty() {
7926 len += 1;
7927 }
7928 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode", len)?;
7929 if !self.tuples.is_empty() {
7930 struct_ser.serialize_field("tuples", &self.tuples)?;
7931 }
7932 if !self.fields.is_empty() {
7933 struct_ser.serialize_field("fields", &self.fields)?;
7934 }
7935 struct_ser.end()
7936 }
7937}
7938impl<'de> serde::Deserialize<'de> for ValuesNode {
7939 #[allow(deprecated)]
7940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7941 where
7942 D: serde::Deserializer<'de>,
7943 {
7944 const FIELDS: &[&str] = &[
7945 "tuples",
7946 "fields",
7947 ];
7948
7949 #[allow(clippy::enum_variant_names)]
7950 enum GeneratedField {
7951 Tuples,
7952 Fields,
7953 }
7954 impl<'de> serde::Deserialize<'de> for GeneratedField {
7955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7956 where
7957 D: serde::Deserializer<'de>,
7958 {
7959 struct GeneratedVisitor;
7960
7961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7962 type Value = GeneratedField;
7963
7964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7965 write!(formatter, "expected one of: {:?}", &FIELDS)
7966 }
7967
7968 #[allow(unused_variables)]
7969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7970 where
7971 E: serde::de::Error,
7972 {
7973 match value {
7974 "tuples" => Ok(GeneratedField::Tuples),
7975 "fields" => Ok(GeneratedField::Fields),
7976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7977 }
7978 }
7979 }
7980 deserializer.deserialize_identifier(GeneratedVisitor)
7981 }
7982 }
7983 struct GeneratedVisitor;
7984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7985 type Value = ValuesNode;
7986
7987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7988 formatter.write_str("struct batch_plan.ValuesNode")
7989 }
7990
7991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
7992 where
7993 V: serde::de::MapAccess<'de>,
7994 {
7995 let mut tuples__ = None;
7996 let mut fields__ = None;
7997 while let Some(k) = map_.next_key()? {
7998 match k {
7999 GeneratedField::Tuples => {
8000 if tuples__.is_some() {
8001 return Err(serde::de::Error::duplicate_field("tuples"));
8002 }
8003 tuples__ = Some(map_.next_value()?);
8004 }
8005 GeneratedField::Fields => {
8006 if fields__.is_some() {
8007 return Err(serde::de::Error::duplicate_field("fields"));
8008 }
8009 fields__ = Some(map_.next_value()?);
8010 }
8011 }
8012 }
8013 Ok(ValuesNode {
8014 tuples: tuples__.unwrap_or_default(),
8015 fields: fields__.unwrap_or_default(),
8016 })
8017 }
8018 }
8019 deserializer.deserialize_struct("batch_plan.ValuesNode", FIELDS, GeneratedVisitor)
8020 }
8021}
8022impl serde::Serialize for values_node::ExprTuple {
8023 #[allow(deprecated)]
8024 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8025 where
8026 S: serde::Serializer,
8027 {
8028 use serde::ser::SerializeStruct;
8029 let mut len = 0;
8030 if !self.cells.is_empty() {
8031 len += 1;
8032 }
8033 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode.ExprTuple", len)?;
8034 if !self.cells.is_empty() {
8035 struct_ser.serialize_field("cells", &self.cells)?;
8036 }
8037 struct_ser.end()
8038 }
8039}
8040impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
8041 #[allow(deprecated)]
8042 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8043 where
8044 D: serde::Deserializer<'de>,
8045 {
8046 const FIELDS: &[&str] = &[
8047 "cells",
8048 ];
8049
8050 #[allow(clippy::enum_variant_names)]
8051 enum GeneratedField {
8052 Cells,
8053 }
8054 impl<'de> serde::Deserialize<'de> for GeneratedField {
8055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8056 where
8057 D: serde::Deserializer<'de>,
8058 {
8059 struct GeneratedVisitor;
8060
8061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8062 type Value = GeneratedField;
8063
8064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8065 write!(formatter, "expected one of: {:?}", &FIELDS)
8066 }
8067
8068 #[allow(unused_variables)]
8069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8070 where
8071 E: serde::de::Error,
8072 {
8073 match value {
8074 "cells" => Ok(GeneratedField::Cells),
8075 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8076 }
8077 }
8078 }
8079 deserializer.deserialize_identifier(GeneratedVisitor)
8080 }
8081 }
8082 struct GeneratedVisitor;
8083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8084 type Value = values_node::ExprTuple;
8085
8086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8087 formatter.write_str("struct batch_plan.ValuesNode.ExprTuple")
8088 }
8089
8090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
8091 where
8092 V: serde::de::MapAccess<'de>,
8093 {
8094 let mut cells__ = None;
8095 while let Some(k) = map_.next_key()? {
8096 match k {
8097 GeneratedField::Cells => {
8098 if cells__.is_some() {
8099 return Err(serde::de::Error::duplicate_field("cells"));
8100 }
8101 cells__ = Some(map_.next_value()?);
8102 }
8103 }
8104 }
8105 Ok(values_node::ExprTuple {
8106 cells: cells__.unwrap_or_default(),
8107 })
8108 }
8109 }
8110 deserializer.deserialize_struct("batch_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
8111 }
8112}
8113impl serde::Serialize for VectorIndexNearestNode {
8114 #[allow(deprecated)]
8115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8116 where
8117 S: serde::Serializer,
8118 {
8119 use serde::ser::SerializeStruct;
8120 let mut len = 0;
8121 if self.table_id != 0 {
8122 len += 1;
8123 }
8124 if !self.info_column_desc.is_empty() {
8125 len += 1;
8126 }
8127 if self.vector_column_idx != 0 {
8128 len += 1;
8129 }
8130 if self.top_n != 0 {
8131 len += 1;
8132 }
8133 if self.distance_type != 0 {
8134 len += 1;
8135 }
8136 if self.hnsw_ef_search != 0 {
8137 len += 1;
8138 }
8139 let mut struct_ser = serializer.serialize_struct("batch_plan.VectorIndexNearestNode", len)?;
8140 if self.table_id != 0 {
8141 struct_ser.serialize_field("tableId", &self.table_id)?;
8142 }
8143 if !self.info_column_desc.is_empty() {
8144 struct_ser.serialize_field("infoColumnDesc", &self.info_column_desc)?;
8145 }
8146 if self.vector_column_idx != 0 {
8147 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
8148 }
8149 if self.top_n != 0 {
8150 struct_ser.serialize_field("topN", &self.top_n)?;
8151 }
8152 if self.distance_type != 0 {
8153 let v = super::common::DistanceType::try_from(self.distance_type)
8154 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
8155 struct_ser.serialize_field("distanceType", &v)?;
8156 }
8157 if self.hnsw_ef_search != 0 {
8158 struct_ser.serialize_field("hnswEfSearch", &self.hnsw_ef_search)?;
8159 }
8160 struct_ser.end()
8161 }
8162}
8163impl<'de> serde::Deserialize<'de> for VectorIndexNearestNode {
8164 #[allow(deprecated)]
8165 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8166 where
8167 D: serde::Deserializer<'de>,
8168 {
8169 const FIELDS: &[&str] = &[
8170 "table_id",
8171 "tableId",
8172 "info_column_desc",
8173 "infoColumnDesc",
8174 "vector_column_idx",
8175 "vectorColumnIdx",
8176 "top_n",
8177 "topN",
8178 "distance_type",
8179 "distanceType",
8180 "hnsw_ef_search",
8181 "hnswEfSearch",
8182 ];
8183
8184 #[allow(clippy::enum_variant_names)]
8185 enum GeneratedField {
8186 TableId,
8187 InfoColumnDesc,
8188 VectorColumnIdx,
8189 TopN,
8190 DistanceType,
8191 HnswEfSearch,
8192 }
8193 impl<'de> serde::Deserialize<'de> for GeneratedField {
8194 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8195 where
8196 D: serde::Deserializer<'de>,
8197 {
8198 struct GeneratedVisitor;
8199
8200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8201 type Value = GeneratedField;
8202
8203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8204 write!(formatter, "expected one of: {:?}", &FIELDS)
8205 }
8206
8207 #[allow(unused_variables)]
8208 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8209 where
8210 E: serde::de::Error,
8211 {
8212 match value {
8213 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8214 "infoColumnDesc" | "info_column_desc" => Ok(GeneratedField::InfoColumnDesc),
8215 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
8216 "topN" | "top_n" => Ok(GeneratedField::TopN),
8217 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
8218 "hnswEfSearch" | "hnsw_ef_search" => Ok(GeneratedField::HnswEfSearch),
8219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8220 }
8221 }
8222 }
8223 deserializer.deserialize_identifier(GeneratedVisitor)
8224 }
8225 }
8226 struct GeneratedVisitor;
8227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8228 type Value = VectorIndexNearestNode;
8229
8230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8231 formatter.write_str("struct batch_plan.VectorIndexNearestNode")
8232 }
8233
8234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexNearestNode, V::Error>
8235 where
8236 V: serde::de::MapAccess<'de>,
8237 {
8238 let mut table_id__ = None;
8239 let mut info_column_desc__ = None;
8240 let mut vector_column_idx__ = None;
8241 let mut top_n__ = None;
8242 let mut distance_type__ = None;
8243 let mut hnsw_ef_search__ = None;
8244 while let Some(k) = map_.next_key()? {
8245 match k {
8246 GeneratedField::TableId => {
8247 if table_id__.is_some() {
8248 return Err(serde::de::Error::duplicate_field("tableId"));
8249 }
8250 table_id__ =
8251 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8252 ;
8253 }
8254 GeneratedField::InfoColumnDesc => {
8255 if info_column_desc__.is_some() {
8256 return Err(serde::de::Error::duplicate_field("infoColumnDesc"));
8257 }
8258 info_column_desc__ = Some(map_.next_value()?);
8259 }
8260 GeneratedField::VectorColumnIdx => {
8261 if vector_column_idx__.is_some() {
8262 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
8263 }
8264 vector_column_idx__ =
8265 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8266 ;
8267 }
8268 GeneratedField::TopN => {
8269 if top_n__.is_some() {
8270 return Err(serde::de::Error::duplicate_field("topN"));
8271 }
8272 top_n__ =
8273 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8274 ;
8275 }
8276 GeneratedField::DistanceType => {
8277 if distance_type__.is_some() {
8278 return Err(serde::de::Error::duplicate_field("distanceType"));
8279 }
8280 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
8281 }
8282 GeneratedField::HnswEfSearch => {
8283 if hnsw_ef_search__.is_some() {
8284 return Err(serde::de::Error::duplicate_field("hnswEfSearch"));
8285 }
8286 hnsw_ef_search__ =
8287 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8288 ;
8289 }
8290 }
8291 }
8292 Ok(VectorIndexNearestNode {
8293 table_id: table_id__.unwrap_or_default(),
8294 info_column_desc: info_column_desc__.unwrap_or_default(),
8295 vector_column_idx: vector_column_idx__.unwrap_or_default(),
8296 top_n: top_n__.unwrap_or_default(),
8297 distance_type: distance_type__.unwrap_or_default(),
8298 hnsw_ef_search: hnsw_ef_search__.unwrap_or_default(),
8299 })
8300 }
8301 }
8302 deserializer.deserialize_struct("batch_plan.VectorIndexNearestNode", FIELDS, GeneratedVisitor)
8303 }
8304}