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 GetChannelDeltaStatsNode {
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.at_time.is_some() {
2371 len += 1;
2372 }
2373 if self.time_offset.is_some() {
2374 len += 1;
2375 }
2376 let mut struct_ser = serializer.serialize_struct("batch_plan.GetChannelDeltaStatsNode", len)?;
2377 if let Some(v) = self.at_time.as_ref() {
2378 #[allow(clippy::needless_borrow)]
2379 #[allow(clippy::needless_borrows_for_generic_args)]
2380 struct_ser.serialize_field("atTime", ToString::to_string(&v).as_str())?;
2381 }
2382 if let Some(v) = self.time_offset.as_ref() {
2383 #[allow(clippy::needless_borrow)]
2384 #[allow(clippy::needless_borrows_for_generic_args)]
2385 struct_ser.serialize_field("timeOffset", ToString::to_string(&v).as_str())?;
2386 }
2387 struct_ser.end()
2388 }
2389}
2390impl<'de> serde::Deserialize<'de> for GetChannelDeltaStatsNode {
2391 #[allow(deprecated)]
2392 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2393 where
2394 D: serde::Deserializer<'de>,
2395 {
2396 const FIELDS: &[&str] = &[
2397 "at_time",
2398 "atTime",
2399 "time_offset",
2400 "timeOffset",
2401 ];
2402
2403 #[allow(clippy::enum_variant_names)]
2404 enum GeneratedField {
2405 AtTime,
2406 TimeOffset,
2407 }
2408 impl<'de> serde::Deserialize<'de> for GeneratedField {
2409 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2410 where
2411 D: serde::Deserializer<'de>,
2412 {
2413 struct GeneratedVisitor;
2414
2415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2416 type Value = GeneratedField;
2417
2418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2419 write!(formatter, "expected one of: {:?}", &FIELDS)
2420 }
2421
2422 #[allow(unused_variables)]
2423 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2424 where
2425 E: serde::de::Error,
2426 {
2427 match value {
2428 "atTime" | "at_time" => Ok(GeneratedField::AtTime),
2429 "timeOffset" | "time_offset" => Ok(GeneratedField::TimeOffset),
2430 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2431 }
2432 }
2433 }
2434 deserializer.deserialize_identifier(GeneratedVisitor)
2435 }
2436 }
2437 struct GeneratedVisitor;
2438 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2439 type Value = GetChannelDeltaStatsNode;
2440
2441 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2442 formatter.write_str("struct batch_plan.GetChannelDeltaStatsNode")
2443 }
2444
2445 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetChannelDeltaStatsNode, V::Error>
2446 where
2447 V: serde::de::MapAccess<'de>,
2448 {
2449 let mut at_time__ = None;
2450 let mut time_offset__ = None;
2451 while let Some(k) = map_.next_key()? {
2452 match k {
2453 GeneratedField::AtTime => {
2454 if at_time__.is_some() {
2455 return Err(serde::de::Error::duplicate_field("atTime"));
2456 }
2457 at_time__ =
2458 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2459 ;
2460 }
2461 GeneratedField::TimeOffset => {
2462 if time_offset__.is_some() {
2463 return Err(serde::de::Error::duplicate_field("timeOffset"));
2464 }
2465 time_offset__ =
2466 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2467 ;
2468 }
2469 }
2470 }
2471 Ok(GetChannelDeltaStatsNode {
2472 at_time: at_time__,
2473 time_offset: time_offset__,
2474 })
2475 }
2476 }
2477 deserializer.deserialize_struct("batch_plan.GetChannelDeltaStatsNode", FIELDS, GeneratedVisitor)
2478 }
2479}
2480impl serde::Serialize for GroupTopNNode {
2481 #[allow(deprecated)]
2482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2483 where
2484 S: serde::Serializer,
2485 {
2486 use serde::ser::SerializeStruct;
2487 let mut len = 0;
2488 if !self.column_orders.is_empty() {
2489 len += 1;
2490 }
2491 if self.limit != 0 {
2492 len += 1;
2493 }
2494 if self.offset != 0 {
2495 len += 1;
2496 }
2497 if !self.group_key.is_empty() {
2498 len += 1;
2499 }
2500 if self.with_ties {
2501 len += 1;
2502 }
2503 let mut struct_ser = serializer.serialize_struct("batch_plan.GroupTopNNode", len)?;
2504 if !self.column_orders.is_empty() {
2505 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
2506 }
2507 if self.limit != 0 {
2508 #[allow(clippy::needless_borrow)]
2509 #[allow(clippy::needless_borrows_for_generic_args)]
2510 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
2511 }
2512 if self.offset != 0 {
2513 #[allow(clippy::needless_borrow)]
2514 #[allow(clippy::needless_borrows_for_generic_args)]
2515 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
2516 }
2517 if !self.group_key.is_empty() {
2518 struct_ser.serialize_field("groupKey", &self.group_key)?;
2519 }
2520 if self.with_ties {
2521 struct_ser.serialize_field("withTies", &self.with_ties)?;
2522 }
2523 struct_ser.end()
2524 }
2525}
2526impl<'de> serde::Deserialize<'de> for GroupTopNNode {
2527 #[allow(deprecated)]
2528 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2529 where
2530 D: serde::Deserializer<'de>,
2531 {
2532 const FIELDS: &[&str] = &[
2533 "column_orders",
2534 "columnOrders",
2535 "limit",
2536 "offset",
2537 "group_key",
2538 "groupKey",
2539 "with_ties",
2540 "withTies",
2541 ];
2542
2543 #[allow(clippy::enum_variant_names)]
2544 enum GeneratedField {
2545 ColumnOrders,
2546 Limit,
2547 Offset,
2548 GroupKey,
2549 WithTies,
2550 }
2551 impl<'de> serde::Deserialize<'de> for GeneratedField {
2552 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2553 where
2554 D: serde::Deserializer<'de>,
2555 {
2556 struct GeneratedVisitor;
2557
2558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2559 type Value = GeneratedField;
2560
2561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2562 write!(formatter, "expected one of: {:?}", &FIELDS)
2563 }
2564
2565 #[allow(unused_variables)]
2566 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2567 where
2568 E: serde::de::Error,
2569 {
2570 match value {
2571 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
2572 "limit" => Ok(GeneratedField::Limit),
2573 "offset" => Ok(GeneratedField::Offset),
2574 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
2575 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
2576 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2577 }
2578 }
2579 }
2580 deserializer.deserialize_identifier(GeneratedVisitor)
2581 }
2582 }
2583 struct GeneratedVisitor;
2584 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2585 type Value = GroupTopNNode;
2586
2587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2588 formatter.write_str("struct batch_plan.GroupTopNNode")
2589 }
2590
2591 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
2592 where
2593 V: serde::de::MapAccess<'de>,
2594 {
2595 let mut column_orders__ = None;
2596 let mut limit__ = None;
2597 let mut offset__ = None;
2598 let mut group_key__ = None;
2599 let mut with_ties__ = None;
2600 while let Some(k) = map_.next_key()? {
2601 match k {
2602 GeneratedField::ColumnOrders => {
2603 if column_orders__.is_some() {
2604 return Err(serde::de::Error::duplicate_field("columnOrders"));
2605 }
2606 column_orders__ = Some(map_.next_value()?);
2607 }
2608 GeneratedField::Limit => {
2609 if limit__.is_some() {
2610 return Err(serde::de::Error::duplicate_field("limit"));
2611 }
2612 limit__ =
2613 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2614 ;
2615 }
2616 GeneratedField::Offset => {
2617 if offset__.is_some() {
2618 return Err(serde::de::Error::duplicate_field("offset"));
2619 }
2620 offset__ =
2621 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2622 ;
2623 }
2624 GeneratedField::GroupKey => {
2625 if group_key__.is_some() {
2626 return Err(serde::de::Error::duplicate_field("groupKey"));
2627 }
2628 group_key__ =
2629 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2630 .into_iter().map(|x| x.0).collect())
2631 ;
2632 }
2633 GeneratedField::WithTies => {
2634 if with_ties__.is_some() {
2635 return Err(serde::de::Error::duplicate_field("withTies"));
2636 }
2637 with_ties__ = Some(map_.next_value()?);
2638 }
2639 }
2640 }
2641 Ok(GroupTopNNode {
2642 column_orders: column_orders__.unwrap_or_default(),
2643 limit: limit__.unwrap_or_default(),
2644 offset: offset__.unwrap_or_default(),
2645 group_key: group_key__.unwrap_or_default(),
2646 with_ties: with_ties__.unwrap_or_default(),
2647 })
2648 }
2649 }
2650 deserializer.deserialize_struct("batch_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
2651 }
2652}
2653impl serde::Serialize for HashAggNode {
2654 #[allow(deprecated)]
2655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2656 where
2657 S: serde::Serializer,
2658 {
2659 use serde::ser::SerializeStruct;
2660 let mut len = 0;
2661 if !self.group_key.is_empty() {
2662 len += 1;
2663 }
2664 if !self.agg_calls.is_empty() {
2665 len += 1;
2666 }
2667 let mut struct_ser = serializer.serialize_struct("batch_plan.HashAggNode", len)?;
2668 if !self.group_key.is_empty() {
2669 struct_ser.serialize_field("groupKey", &self.group_key)?;
2670 }
2671 if !self.agg_calls.is_empty() {
2672 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
2673 }
2674 struct_ser.end()
2675 }
2676}
2677impl<'de> serde::Deserialize<'de> for HashAggNode {
2678 #[allow(deprecated)]
2679 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2680 where
2681 D: serde::Deserializer<'de>,
2682 {
2683 const FIELDS: &[&str] = &[
2684 "group_key",
2685 "groupKey",
2686 "agg_calls",
2687 "aggCalls",
2688 ];
2689
2690 #[allow(clippy::enum_variant_names)]
2691 enum GeneratedField {
2692 GroupKey,
2693 AggCalls,
2694 }
2695 impl<'de> serde::Deserialize<'de> for GeneratedField {
2696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2697 where
2698 D: serde::Deserializer<'de>,
2699 {
2700 struct GeneratedVisitor;
2701
2702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2703 type Value = GeneratedField;
2704
2705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2706 write!(formatter, "expected one of: {:?}", &FIELDS)
2707 }
2708
2709 #[allow(unused_variables)]
2710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2711 where
2712 E: serde::de::Error,
2713 {
2714 match value {
2715 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
2716 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
2717 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2718 }
2719 }
2720 }
2721 deserializer.deserialize_identifier(GeneratedVisitor)
2722 }
2723 }
2724 struct GeneratedVisitor;
2725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2726 type Value = HashAggNode;
2727
2728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2729 formatter.write_str("struct batch_plan.HashAggNode")
2730 }
2731
2732 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
2733 where
2734 V: serde::de::MapAccess<'de>,
2735 {
2736 let mut group_key__ = None;
2737 let mut agg_calls__ = None;
2738 while let Some(k) = map_.next_key()? {
2739 match k {
2740 GeneratedField::GroupKey => {
2741 if group_key__.is_some() {
2742 return Err(serde::de::Error::duplicate_field("groupKey"));
2743 }
2744 group_key__ =
2745 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2746 .into_iter().map(|x| x.0).collect())
2747 ;
2748 }
2749 GeneratedField::AggCalls => {
2750 if agg_calls__.is_some() {
2751 return Err(serde::de::Error::duplicate_field("aggCalls"));
2752 }
2753 agg_calls__ = Some(map_.next_value()?);
2754 }
2755 }
2756 }
2757 Ok(HashAggNode {
2758 group_key: group_key__.unwrap_or_default(),
2759 agg_calls: agg_calls__.unwrap_or_default(),
2760 })
2761 }
2762 }
2763 deserializer.deserialize_struct("batch_plan.HashAggNode", FIELDS, GeneratedVisitor)
2764 }
2765}
2766impl serde::Serialize for HashJoinNode {
2767 #[allow(deprecated)]
2768 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2769 where
2770 S: serde::Serializer,
2771 {
2772 use serde::ser::SerializeStruct;
2773 let mut len = 0;
2774 if self.join_type != 0 {
2775 len += 1;
2776 }
2777 if !self.left_key.is_empty() {
2778 len += 1;
2779 }
2780 if !self.right_key.is_empty() {
2781 len += 1;
2782 }
2783 if self.condition.is_some() {
2784 len += 1;
2785 }
2786 if !self.output_indices.is_empty() {
2787 len += 1;
2788 }
2789 if !self.null_safe.is_empty() {
2790 len += 1;
2791 }
2792 if self.asof_desc.is_some() {
2793 len += 1;
2794 }
2795 let mut struct_ser = serializer.serialize_struct("batch_plan.HashJoinNode", len)?;
2796 if self.join_type != 0 {
2797 let v = super::plan_common::JoinType::try_from(self.join_type)
2798 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2799 struct_ser.serialize_field("joinType", &v)?;
2800 }
2801 if !self.left_key.is_empty() {
2802 struct_ser.serialize_field("leftKey", &self.left_key)?;
2803 }
2804 if !self.right_key.is_empty() {
2805 struct_ser.serialize_field("rightKey", &self.right_key)?;
2806 }
2807 if let Some(v) = self.condition.as_ref() {
2808 struct_ser.serialize_field("condition", v)?;
2809 }
2810 if !self.output_indices.is_empty() {
2811 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2812 }
2813 if !self.null_safe.is_empty() {
2814 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
2815 }
2816 if let Some(v) = self.asof_desc.as_ref() {
2817 struct_ser.serialize_field("asofDesc", v)?;
2818 }
2819 struct_ser.end()
2820 }
2821}
2822impl<'de> serde::Deserialize<'de> for HashJoinNode {
2823 #[allow(deprecated)]
2824 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2825 where
2826 D: serde::Deserializer<'de>,
2827 {
2828 const FIELDS: &[&str] = &[
2829 "join_type",
2830 "joinType",
2831 "left_key",
2832 "leftKey",
2833 "right_key",
2834 "rightKey",
2835 "condition",
2836 "output_indices",
2837 "outputIndices",
2838 "null_safe",
2839 "nullSafe",
2840 "asof_desc",
2841 "asofDesc",
2842 ];
2843
2844 #[allow(clippy::enum_variant_names)]
2845 enum GeneratedField {
2846 JoinType,
2847 LeftKey,
2848 RightKey,
2849 Condition,
2850 OutputIndices,
2851 NullSafe,
2852 AsofDesc,
2853 }
2854 impl<'de> serde::Deserialize<'de> for GeneratedField {
2855 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2856 where
2857 D: serde::Deserializer<'de>,
2858 {
2859 struct GeneratedVisitor;
2860
2861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2862 type Value = GeneratedField;
2863
2864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2865 write!(formatter, "expected one of: {:?}", &FIELDS)
2866 }
2867
2868 #[allow(unused_variables)]
2869 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2870 where
2871 E: serde::de::Error,
2872 {
2873 match value {
2874 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
2875 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
2876 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
2877 "condition" => Ok(GeneratedField::Condition),
2878 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2879 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
2880 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
2881 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2882 }
2883 }
2884 }
2885 deserializer.deserialize_identifier(GeneratedVisitor)
2886 }
2887 }
2888 struct GeneratedVisitor;
2889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2890 type Value = HashJoinNode;
2891
2892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2893 formatter.write_str("struct batch_plan.HashJoinNode")
2894 }
2895
2896 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
2897 where
2898 V: serde::de::MapAccess<'de>,
2899 {
2900 let mut join_type__ = None;
2901 let mut left_key__ = None;
2902 let mut right_key__ = None;
2903 let mut condition__ = None;
2904 let mut output_indices__ = None;
2905 let mut null_safe__ = None;
2906 let mut asof_desc__ = None;
2907 while let Some(k) = map_.next_key()? {
2908 match k {
2909 GeneratedField::JoinType => {
2910 if join_type__.is_some() {
2911 return Err(serde::de::Error::duplicate_field("joinType"));
2912 }
2913 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
2914 }
2915 GeneratedField::LeftKey => {
2916 if left_key__.is_some() {
2917 return Err(serde::de::Error::duplicate_field("leftKey"));
2918 }
2919 left_key__ =
2920 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2921 .into_iter().map(|x| x.0).collect())
2922 ;
2923 }
2924 GeneratedField::RightKey => {
2925 if right_key__.is_some() {
2926 return Err(serde::de::Error::duplicate_field("rightKey"));
2927 }
2928 right_key__ =
2929 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2930 .into_iter().map(|x| x.0).collect())
2931 ;
2932 }
2933 GeneratedField::Condition => {
2934 if condition__.is_some() {
2935 return Err(serde::de::Error::duplicate_field("condition"));
2936 }
2937 condition__ = map_.next_value()?;
2938 }
2939 GeneratedField::OutputIndices => {
2940 if output_indices__.is_some() {
2941 return Err(serde::de::Error::duplicate_field("outputIndices"));
2942 }
2943 output_indices__ =
2944 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2945 .into_iter().map(|x| x.0).collect())
2946 ;
2947 }
2948 GeneratedField::NullSafe => {
2949 if null_safe__.is_some() {
2950 return Err(serde::de::Error::duplicate_field("nullSafe"));
2951 }
2952 null_safe__ = Some(map_.next_value()?);
2953 }
2954 GeneratedField::AsofDesc => {
2955 if asof_desc__.is_some() {
2956 return Err(serde::de::Error::duplicate_field("asofDesc"));
2957 }
2958 asof_desc__ = map_.next_value()?;
2959 }
2960 }
2961 }
2962 Ok(HashJoinNode {
2963 join_type: join_type__.unwrap_or_default(),
2964 left_key: left_key__.unwrap_or_default(),
2965 right_key: right_key__.unwrap_or_default(),
2966 condition: condition__,
2967 output_indices: output_indices__.unwrap_or_default(),
2968 null_safe: null_safe__.unwrap_or_default(),
2969 asof_desc: asof_desc__,
2970 })
2971 }
2972 }
2973 deserializer.deserialize_struct("batch_plan.HashJoinNode", FIELDS, GeneratedVisitor)
2974 }
2975}
2976impl serde::Serialize for HopWindowNode {
2977 #[allow(deprecated)]
2978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2979 where
2980 S: serde::Serializer,
2981 {
2982 use serde::ser::SerializeStruct;
2983 let mut len = 0;
2984 if self.time_col != 0 {
2985 len += 1;
2986 }
2987 if self.window_slide.is_some() {
2988 len += 1;
2989 }
2990 if self.window_size.is_some() {
2991 len += 1;
2992 }
2993 if !self.output_indices.is_empty() {
2994 len += 1;
2995 }
2996 if !self.window_start_exprs.is_empty() {
2997 len += 1;
2998 }
2999 if !self.window_end_exprs.is_empty() {
3000 len += 1;
3001 }
3002 let mut struct_ser = serializer.serialize_struct("batch_plan.HopWindowNode", len)?;
3003 if self.time_col != 0 {
3004 struct_ser.serialize_field("timeCol", &self.time_col)?;
3005 }
3006 if let Some(v) = self.window_slide.as_ref() {
3007 struct_ser.serialize_field("windowSlide", v)?;
3008 }
3009 if let Some(v) = self.window_size.as_ref() {
3010 struct_ser.serialize_field("windowSize", v)?;
3011 }
3012 if !self.output_indices.is_empty() {
3013 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3014 }
3015 if !self.window_start_exprs.is_empty() {
3016 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
3017 }
3018 if !self.window_end_exprs.is_empty() {
3019 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
3020 }
3021 struct_ser.end()
3022 }
3023}
3024impl<'de> serde::Deserialize<'de> for HopWindowNode {
3025 #[allow(deprecated)]
3026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3027 where
3028 D: serde::Deserializer<'de>,
3029 {
3030 const FIELDS: &[&str] = &[
3031 "time_col",
3032 "timeCol",
3033 "window_slide",
3034 "windowSlide",
3035 "window_size",
3036 "windowSize",
3037 "output_indices",
3038 "outputIndices",
3039 "window_start_exprs",
3040 "windowStartExprs",
3041 "window_end_exprs",
3042 "windowEndExprs",
3043 ];
3044
3045 #[allow(clippy::enum_variant_names)]
3046 enum GeneratedField {
3047 TimeCol,
3048 WindowSlide,
3049 WindowSize,
3050 OutputIndices,
3051 WindowStartExprs,
3052 WindowEndExprs,
3053 }
3054 impl<'de> serde::Deserialize<'de> for GeneratedField {
3055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3056 where
3057 D: serde::Deserializer<'de>,
3058 {
3059 struct GeneratedVisitor;
3060
3061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3062 type Value = GeneratedField;
3063
3064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3065 write!(formatter, "expected one of: {:?}", &FIELDS)
3066 }
3067
3068 #[allow(unused_variables)]
3069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3070 where
3071 E: serde::de::Error,
3072 {
3073 match value {
3074 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
3075 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
3076 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
3077 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3078 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
3079 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
3080 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3081 }
3082 }
3083 }
3084 deserializer.deserialize_identifier(GeneratedVisitor)
3085 }
3086 }
3087 struct GeneratedVisitor;
3088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3089 type Value = HopWindowNode;
3090
3091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3092 formatter.write_str("struct batch_plan.HopWindowNode")
3093 }
3094
3095 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
3096 where
3097 V: serde::de::MapAccess<'de>,
3098 {
3099 let mut time_col__ = None;
3100 let mut window_slide__ = None;
3101 let mut window_size__ = None;
3102 let mut output_indices__ = None;
3103 let mut window_start_exprs__ = None;
3104 let mut window_end_exprs__ = None;
3105 while let Some(k) = map_.next_key()? {
3106 match k {
3107 GeneratedField::TimeCol => {
3108 if time_col__.is_some() {
3109 return Err(serde::de::Error::duplicate_field("timeCol"));
3110 }
3111 time_col__ =
3112 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3113 ;
3114 }
3115 GeneratedField::WindowSlide => {
3116 if window_slide__.is_some() {
3117 return Err(serde::de::Error::duplicate_field("windowSlide"));
3118 }
3119 window_slide__ = map_.next_value()?;
3120 }
3121 GeneratedField::WindowSize => {
3122 if window_size__.is_some() {
3123 return Err(serde::de::Error::duplicate_field("windowSize"));
3124 }
3125 window_size__ = map_.next_value()?;
3126 }
3127 GeneratedField::OutputIndices => {
3128 if output_indices__.is_some() {
3129 return Err(serde::de::Error::duplicate_field("outputIndices"));
3130 }
3131 output_indices__ =
3132 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3133 .into_iter().map(|x| x.0).collect())
3134 ;
3135 }
3136 GeneratedField::WindowStartExprs => {
3137 if window_start_exprs__.is_some() {
3138 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
3139 }
3140 window_start_exprs__ = Some(map_.next_value()?);
3141 }
3142 GeneratedField::WindowEndExprs => {
3143 if window_end_exprs__.is_some() {
3144 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
3145 }
3146 window_end_exprs__ = Some(map_.next_value()?);
3147 }
3148 }
3149 }
3150 Ok(HopWindowNode {
3151 time_col: time_col__.unwrap_or_default(),
3152 window_slide: window_slide__,
3153 window_size: window_size__,
3154 output_indices: output_indices__.unwrap_or_default(),
3155 window_start_exprs: window_start_exprs__.unwrap_or_default(),
3156 window_end_exprs: window_end_exprs__.unwrap_or_default(),
3157 })
3158 }
3159 }
3160 deserializer.deserialize_struct("batch_plan.HopWindowNode", FIELDS, GeneratedVisitor)
3161 }
3162}
3163impl serde::Serialize for IcebergScanNode {
3164 #[allow(deprecated)]
3165 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3166 where
3167 S: serde::Serializer,
3168 {
3169 use serde::ser::SerializeStruct;
3170 let mut len = 0;
3171 if !self.columns.is_empty() {
3172 len += 1;
3173 }
3174 if !self.with_properties.is_empty() {
3175 len += 1;
3176 }
3177 if !self.split.is_empty() {
3178 len += 1;
3179 }
3180 if !self.secret_refs.is_empty() {
3181 len += 1;
3182 }
3183 if self.iceberg_scan_type != 0 {
3184 len += 1;
3185 }
3186 let mut struct_ser = serializer.serialize_struct("batch_plan.IcebergScanNode", len)?;
3187 if !self.columns.is_empty() {
3188 struct_ser.serialize_field("columns", &self.columns)?;
3189 }
3190 if !self.with_properties.is_empty() {
3191 struct_ser.serialize_field("withProperties", &self.with_properties)?;
3192 }
3193 if !self.split.is_empty() {
3194 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
3195 }
3196 if !self.secret_refs.is_empty() {
3197 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3198 }
3199 if self.iceberg_scan_type != 0 {
3200 let v = iceberg_scan_node::IcebergScanType::try_from(self.iceberg_scan_type)
3201 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.iceberg_scan_type)))?;
3202 struct_ser.serialize_field("icebergScanType", &v)?;
3203 }
3204 struct_ser.end()
3205 }
3206}
3207impl<'de> serde::Deserialize<'de> for IcebergScanNode {
3208 #[allow(deprecated)]
3209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3210 where
3211 D: serde::Deserializer<'de>,
3212 {
3213 const FIELDS: &[&str] = &[
3214 "columns",
3215 "with_properties",
3216 "withProperties",
3217 "split",
3218 "secret_refs",
3219 "secretRefs",
3220 "iceberg_scan_type",
3221 "icebergScanType",
3222 ];
3223
3224 #[allow(clippy::enum_variant_names)]
3225 enum GeneratedField {
3226 Columns,
3227 WithProperties,
3228 Split,
3229 SecretRefs,
3230 IcebergScanType,
3231 }
3232 impl<'de> serde::Deserialize<'de> for GeneratedField {
3233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3234 where
3235 D: serde::Deserializer<'de>,
3236 {
3237 struct GeneratedVisitor;
3238
3239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3240 type Value = GeneratedField;
3241
3242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3243 write!(formatter, "expected one of: {:?}", &FIELDS)
3244 }
3245
3246 #[allow(unused_variables)]
3247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3248 where
3249 E: serde::de::Error,
3250 {
3251 match value {
3252 "columns" => Ok(GeneratedField::Columns),
3253 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
3254 "split" => Ok(GeneratedField::Split),
3255 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3256 "icebergScanType" | "iceberg_scan_type" => Ok(GeneratedField::IcebergScanType),
3257 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3258 }
3259 }
3260 }
3261 deserializer.deserialize_identifier(GeneratedVisitor)
3262 }
3263 }
3264 struct GeneratedVisitor;
3265 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3266 type Value = IcebergScanNode;
3267
3268 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3269 formatter.write_str("struct batch_plan.IcebergScanNode")
3270 }
3271
3272 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergScanNode, V::Error>
3273 where
3274 V: serde::de::MapAccess<'de>,
3275 {
3276 let mut columns__ = None;
3277 let mut with_properties__ = None;
3278 let mut split__ = None;
3279 let mut secret_refs__ = None;
3280 let mut iceberg_scan_type__ = None;
3281 while let Some(k) = map_.next_key()? {
3282 match k {
3283 GeneratedField::Columns => {
3284 if columns__.is_some() {
3285 return Err(serde::de::Error::duplicate_field("columns"));
3286 }
3287 columns__ = Some(map_.next_value()?);
3288 }
3289 GeneratedField::WithProperties => {
3290 if with_properties__.is_some() {
3291 return Err(serde::de::Error::duplicate_field("withProperties"));
3292 }
3293 with_properties__ = Some(
3294 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3295 );
3296 }
3297 GeneratedField::Split => {
3298 if split__.is_some() {
3299 return Err(serde::de::Error::duplicate_field("split"));
3300 }
3301 split__ =
3302 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
3303 .into_iter().map(|x| x.0).collect())
3304 ;
3305 }
3306 GeneratedField::SecretRefs => {
3307 if secret_refs__.is_some() {
3308 return Err(serde::de::Error::duplicate_field("secretRefs"));
3309 }
3310 secret_refs__ = Some(
3311 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3312 );
3313 }
3314 GeneratedField::IcebergScanType => {
3315 if iceberg_scan_type__.is_some() {
3316 return Err(serde::de::Error::duplicate_field("icebergScanType"));
3317 }
3318 iceberg_scan_type__ = Some(map_.next_value::<iceberg_scan_node::IcebergScanType>()? as i32);
3319 }
3320 }
3321 }
3322 Ok(IcebergScanNode {
3323 columns: columns__.unwrap_or_default(),
3324 with_properties: with_properties__.unwrap_or_default(),
3325 split: split__.unwrap_or_default(),
3326 secret_refs: secret_refs__.unwrap_or_default(),
3327 iceberg_scan_type: iceberg_scan_type__.unwrap_or_default(),
3328 })
3329 }
3330 }
3331 deserializer.deserialize_struct("batch_plan.IcebergScanNode", FIELDS, GeneratedVisitor)
3332 }
3333}
3334impl serde::Serialize for iceberg_scan_node::IcebergScanType {
3335 #[allow(deprecated)]
3336 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3337 where
3338 S: serde::Serializer,
3339 {
3340 let variant = match self {
3341 Self::Unspecified => "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3342 Self::DataScan => "ICEBERG_SCAN_TYPE_DATA_SCAN",
3343 Self::EqualityDeleteScan => "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3344 Self::PositionDeleteScan => "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3345 Self::CountStar => "ICEBERG_SCAN_TYPE_COUNT_STAR",
3346 };
3347 serializer.serialize_str(variant)
3348 }
3349}
3350impl<'de> serde::Deserialize<'de> for iceberg_scan_node::IcebergScanType {
3351 #[allow(deprecated)]
3352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3353 where
3354 D: serde::Deserializer<'de>,
3355 {
3356 const FIELDS: &[&str] = &[
3357 "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3358 "ICEBERG_SCAN_TYPE_DATA_SCAN",
3359 "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3360 "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3361 "ICEBERG_SCAN_TYPE_COUNT_STAR",
3362 ];
3363
3364 struct GeneratedVisitor;
3365
3366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3367 type Value = iceberg_scan_node::IcebergScanType;
3368
3369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3370 write!(formatter, "expected one of: {:?}", &FIELDS)
3371 }
3372
3373 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3374 where
3375 E: serde::de::Error,
3376 {
3377 i32::try_from(v)
3378 .ok()
3379 .and_then(|x| x.try_into().ok())
3380 .ok_or_else(|| {
3381 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3382 })
3383 }
3384
3385 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3386 where
3387 E: serde::de::Error,
3388 {
3389 i32::try_from(v)
3390 .ok()
3391 .and_then(|x| x.try_into().ok())
3392 .ok_or_else(|| {
3393 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3394 })
3395 }
3396
3397 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3398 where
3399 E: serde::de::Error,
3400 {
3401 match value {
3402 "ICEBERG_SCAN_TYPE_UNSPECIFIED" => Ok(iceberg_scan_node::IcebergScanType::Unspecified),
3403 "ICEBERG_SCAN_TYPE_DATA_SCAN" => Ok(iceberg_scan_node::IcebergScanType::DataScan),
3404 "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::EqualityDeleteScan),
3405 "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::PositionDeleteScan),
3406 "ICEBERG_SCAN_TYPE_COUNT_STAR" => Ok(iceberg_scan_node::IcebergScanType::CountStar),
3407 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3408 }
3409 }
3410 }
3411 deserializer.deserialize_any(GeneratedVisitor)
3412 }
3413}
3414impl serde::Serialize for InsertNode {
3415 #[allow(deprecated)]
3416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3417 where
3418 S: serde::Serializer,
3419 {
3420 use serde::ser::SerializeStruct;
3421 let mut len = 0;
3422 if self.table_id != 0 {
3423 len += 1;
3424 }
3425 if self.table_version_id != 0 {
3426 len += 1;
3427 }
3428 if !self.column_indices.is_empty() {
3429 len += 1;
3430 }
3431 if self.default_columns.is_some() {
3432 len += 1;
3433 }
3434 if self.row_id_index.is_some() {
3435 len += 1;
3436 }
3437 if self.returning {
3438 len += 1;
3439 }
3440 if self.session_id != 0 {
3441 len += 1;
3442 }
3443 let mut struct_ser = serializer.serialize_struct("batch_plan.InsertNode", len)?;
3444 if self.table_id != 0 {
3445 struct_ser.serialize_field("tableId", &self.table_id)?;
3446 }
3447 if self.table_version_id != 0 {
3448 #[allow(clippy::needless_borrow)]
3449 #[allow(clippy::needless_borrows_for_generic_args)]
3450 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3451 }
3452 if !self.column_indices.is_empty() {
3453 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
3454 }
3455 if let Some(v) = self.default_columns.as_ref() {
3456 struct_ser.serialize_field("defaultColumns", v)?;
3457 }
3458 if let Some(v) = self.row_id_index.as_ref() {
3459 struct_ser.serialize_field("rowIdIndex", v)?;
3460 }
3461 if self.returning {
3462 struct_ser.serialize_field("returning", &self.returning)?;
3463 }
3464 if self.session_id != 0 {
3465 struct_ser.serialize_field("sessionId", &self.session_id)?;
3466 }
3467 struct_ser.end()
3468 }
3469}
3470impl<'de> serde::Deserialize<'de> for InsertNode {
3471 #[allow(deprecated)]
3472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3473 where
3474 D: serde::Deserializer<'de>,
3475 {
3476 const FIELDS: &[&str] = &[
3477 "table_id",
3478 "tableId",
3479 "table_version_id",
3480 "tableVersionId",
3481 "column_indices",
3482 "columnIndices",
3483 "default_columns",
3484 "defaultColumns",
3485 "row_id_index",
3486 "rowIdIndex",
3487 "returning",
3488 "session_id",
3489 "sessionId",
3490 ];
3491
3492 #[allow(clippy::enum_variant_names)]
3493 enum GeneratedField {
3494 TableId,
3495 TableVersionId,
3496 ColumnIndices,
3497 DefaultColumns,
3498 RowIdIndex,
3499 Returning,
3500 SessionId,
3501 }
3502 impl<'de> serde::Deserialize<'de> for GeneratedField {
3503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3504 where
3505 D: serde::Deserializer<'de>,
3506 {
3507 struct GeneratedVisitor;
3508
3509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3510 type Value = GeneratedField;
3511
3512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3513 write!(formatter, "expected one of: {:?}", &FIELDS)
3514 }
3515
3516 #[allow(unused_variables)]
3517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3518 where
3519 E: serde::de::Error,
3520 {
3521 match value {
3522 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3523 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3524 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
3525 "defaultColumns" | "default_columns" => Ok(GeneratedField::DefaultColumns),
3526 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
3527 "returning" => Ok(GeneratedField::Returning),
3528 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
3529 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3530 }
3531 }
3532 }
3533 deserializer.deserialize_identifier(GeneratedVisitor)
3534 }
3535 }
3536 struct GeneratedVisitor;
3537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3538 type Value = InsertNode;
3539
3540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3541 formatter.write_str("struct batch_plan.InsertNode")
3542 }
3543
3544 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InsertNode, V::Error>
3545 where
3546 V: serde::de::MapAccess<'de>,
3547 {
3548 let mut table_id__ = None;
3549 let mut table_version_id__ = None;
3550 let mut column_indices__ = None;
3551 let mut default_columns__ = None;
3552 let mut row_id_index__ = None;
3553 let mut returning__ = None;
3554 let mut session_id__ = None;
3555 while let Some(k) = map_.next_key()? {
3556 match k {
3557 GeneratedField::TableId => {
3558 if table_id__.is_some() {
3559 return Err(serde::de::Error::duplicate_field("tableId"));
3560 }
3561 table_id__ =
3562 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3563 ;
3564 }
3565 GeneratedField::TableVersionId => {
3566 if table_version_id__.is_some() {
3567 return Err(serde::de::Error::duplicate_field("tableVersionId"));
3568 }
3569 table_version_id__ =
3570 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3571 ;
3572 }
3573 GeneratedField::ColumnIndices => {
3574 if column_indices__.is_some() {
3575 return Err(serde::de::Error::duplicate_field("columnIndices"));
3576 }
3577 column_indices__ =
3578 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3579 .into_iter().map(|x| x.0).collect())
3580 ;
3581 }
3582 GeneratedField::DefaultColumns => {
3583 if default_columns__.is_some() {
3584 return Err(serde::de::Error::duplicate_field("defaultColumns"));
3585 }
3586 default_columns__ = map_.next_value()?;
3587 }
3588 GeneratedField::RowIdIndex => {
3589 if row_id_index__.is_some() {
3590 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
3591 }
3592 row_id_index__ =
3593 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3594 ;
3595 }
3596 GeneratedField::Returning => {
3597 if returning__.is_some() {
3598 return Err(serde::de::Error::duplicate_field("returning"));
3599 }
3600 returning__ = Some(map_.next_value()?);
3601 }
3602 GeneratedField::SessionId => {
3603 if session_id__.is_some() {
3604 return Err(serde::de::Error::duplicate_field("sessionId"));
3605 }
3606 session_id__ =
3607 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3608 ;
3609 }
3610 }
3611 }
3612 Ok(InsertNode {
3613 table_id: table_id__.unwrap_or_default(),
3614 table_version_id: table_version_id__.unwrap_or_default(),
3615 column_indices: column_indices__.unwrap_or_default(),
3616 default_columns: default_columns__,
3617 row_id_index: row_id_index__,
3618 returning: returning__.unwrap_or_default(),
3619 session_id: session_id__.unwrap_or_default(),
3620 })
3621 }
3622 }
3623 deserializer.deserialize_struct("batch_plan.InsertNode", FIELDS, GeneratedVisitor)
3624 }
3625}
3626impl serde::Serialize for LimitNode {
3627 #[allow(deprecated)]
3628 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3629 where
3630 S: serde::Serializer,
3631 {
3632 use serde::ser::SerializeStruct;
3633 let mut len = 0;
3634 if self.limit != 0 {
3635 len += 1;
3636 }
3637 if self.offset != 0 {
3638 len += 1;
3639 }
3640 let mut struct_ser = serializer.serialize_struct("batch_plan.LimitNode", len)?;
3641 if self.limit != 0 {
3642 #[allow(clippy::needless_borrow)]
3643 #[allow(clippy::needless_borrows_for_generic_args)]
3644 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
3645 }
3646 if self.offset != 0 {
3647 #[allow(clippy::needless_borrow)]
3648 #[allow(clippy::needless_borrows_for_generic_args)]
3649 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
3650 }
3651 struct_ser.end()
3652 }
3653}
3654impl<'de> serde::Deserialize<'de> for LimitNode {
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 "limit",
3662 "offset",
3663 ];
3664
3665 #[allow(clippy::enum_variant_names)]
3666 enum GeneratedField {
3667 Limit,
3668 Offset,
3669 }
3670 impl<'de> serde::Deserialize<'de> for GeneratedField {
3671 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3672 where
3673 D: serde::Deserializer<'de>,
3674 {
3675 struct GeneratedVisitor;
3676
3677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3678 type Value = GeneratedField;
3679
3680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3681 write!(formatter, "expected one of: {:?}", &FIELDS)
3682 }
3683
3684 #[allow(unused_variables)]
3685 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3686 where
3687 E: serde::de::Error,
3688 {
3689 match value {
3690 "limit" => Ok(GeneratedField::Limit),
3691 "offset" => Ok(GeneratedField::Offset),
3692 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3693 }
3694 }
3695 }
3696 deserializer.deserialize_identifier(GeneratedVisitor)
3697 }
3698 }
3699 struct GeneratedVisitor;
3700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3701 type Value = LimitNode;
3702
3703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3704 formatter.write_str("struct batch_plan.LimitNode")
3705 }
3706
3707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LimitNode, V::Error>
3708 where
3709 V: serde::de::MapAccess<'de>,
3710 {
3711 let mut limit__ = None;
3712 let mut offset__ = None;
3713 while let Some(k) = map_.next_key()? {
3714 match k {
3715 GeneratedField::Limit => {
3716 if limit__.is_some() {
3717 return Err(serde::de::Error::duplicate_field("limit"));
3718 }
3719 limit__ =
3720 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3721 ;
3722 }
3723 GeneratedField::Offset => {
3724 if offset__.is_some() {
3725 return Err(serde::de::Error::duplicate_field("offset"));
3726 }
3727 offset__ =
3728 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3729 ;
3730 }
3731 }
3732 }
3733 Ok(LimitNode {
3734 limit: limit__.unwrap_or_default(),
3735 offset: offset__.unwrap_or_default(),
3736 })
3737 }
3738 }
3739 deserializer.deserialize_struct("batch_plan.LimitNode", FIELDS, GeneratedVisitor)
3740 }
3741}
3742impl serde::Serialize for LocalExecutePlan {
3743 #[allow(deprecated)]
3744 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3745 where
3746 S: serde::Serializer,
3747 {
3748 use serde::ser::SerializeStruct;
3749 let mut len = 0;
3750 if self.plan.is_some() {
3751 len += 1;
3752 }
3753 if self.epoch.is_some() {
3754 len += 1;
3755 }
3756 if !self.tracing_context.is_empty() {
3757 len += 1;
3758 }
3759 let mut struct_ser = serializer.serialize_struct("batch_plan.LocalExecutePlan", len)?;
3760 if let Some(v) = self.plan.as_ref() {
3761 struct_ser.serialize_field("plan", v)?;
3762 }
3763 if let Some(v) = self.epoch.as_ref() {
3764 struct_ser.serialize_field("epoch", v)?;
3765 }
3766 if !self.tracing_context.is_empty() {
3767 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
3768 }
3769 struct_ser.end()
3770 }
3771}
3772impl<'de> serde::Deserialize<'de> for LocalExecutePlan {
3773 #[allow(deprecated)]
3774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3775 where
3776 D: serde::Deserializer<'de>,
3777 {
3778 const FIELDS: &[&str] = &[
3779 "plan",
3780 "epoch",
3781 "tracing_context",
3782 "tracingContext",
3783 ];
3784
3785 #[allow(clippy::enum_variant_names)]
3786 enum GeneratedField {
3787 Plan,
3788 Epoch,
3789 TracingContext,
3790 }
3791 impl<'de> serde::Deserialize<'de> for GeneratedField {
3792 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3793 where
3794 D: serde::Deserializer<'de>,
3795 {
3796 struct GeneratedVisitor;
3797
3798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3799 type Value = GeneratedField;
3800
3801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3802 write!(formatter, "expected one of: {:?}", &FIELDS)
3803 }
3804
3805 #[allow(unused_variables)]
3806 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3807 where
3808 E: serde::de::Error,
3809 {
3810 match value {
3811 "plan" => Ok(GeneratedField::Plan),
3812 "epoch" => Ok(GeneratedField::Epoch),
3813 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
3814 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3815 }
3816 }
3817 }
3818 deserializer.deserialize_identifier(GeneratedVisitor)
3819 }
3820 }
3821 struct GeneratedVisitor;
3822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3823 type Value = LocalExecutePlan;
3824
3825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3826 formatter.write_str("struct batch_plan.LocalExecutePlan")
3827 }
3828
3829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalExecutePlan, V::Error>
3830 where
3831 V: serde::de::MapAccess<'de>,
3832 {
3833 let mut plan__ = None;
3834 let mut epoch__ = None;
3835 let mut tracing_context__ = None;
3836 while let Some(k) = map_.next_key()? {
3837 match k {
3838 GeneratedField::Plan => {
3839 if plan__.is_some() {
3840 return Err(serde::de::Error::duplicate_field("plan"));
3841 }
3842 plan__ = map_.next_value()?;
3843 }
3844 GeneratedField::Epoch => {
3845 if epoch__.is_some() {
3846 return Err(serde::de::Error::duplicate_field("epoch"));
3847 }
3848 epoch__ = map_.next_value()?;
3849 }
3850 GeneratedField::TracingContext => {
3851 if tracing_context__.is_some() {
3852 return Err(serde::de::Error::duplicate_field("tracingContext"));
3853 }
3854 tracing_context__ = Some(
3855 map_.next_value::<std::collections::HashMap<_, _>>()?
3856 );
3857 }
3858 }
3859 }
3860 Ok(LocalExecutePlan {
3861 plan: plan__,
3862 epoch: epoch__,
3863 tracing_context: tracing_context__.unwrap_or_default(),
3864 })
3865 }
3866 }
3867 deserializer.deserialize_struct("batch_plan.LocalExecutePlan", FIELDS, GeneratedVisitor)
3868 }
3869}
3870impl serde::Serialize for LocalLookupJoinNode {
3871 #[allow(deprecated)]
3872 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3873 where
3874 S: serde::Serializer,
3875 {
3876 use serde::ser::SerializeStruct;
3877 let mut len = 0;
3878 if self.join_type != 0 {
3879 len += 1;
3880 }
3881 if self.condition.is_some() {
3882 len += 1;
3883 }
3884 if !self.outer_side_key.is_empty() {
3885 len += 1;
3886 }
3887 if !self.inner_side_key.is_empty() {
3888 len += 1;
3889 }
3890 if self.lookup_prefix_len != 0 {
3891 len += 1;
3892 }
3893 if self.inner_side_table_desc.is_some() {
3894 len += 1;
3895 }
3896 if !self.inner_side_vnode_mapping.is_empty() {
3897 len += 1;
3898 }
3899 if !self.inner_side_column_ids.is_empty() {
3900 len += 1;
3901 }
3902 if !self.output_indices.is_empty() {
3903 len += 1;
3904 }
3905 if !self.worker_nodes.is_empty() {
3906 len += 1;
3907 }
3908 if !self.null_safe.is_empty() {
3909 len += 1;
3910 }
3911 if self.as_of.is_some() {
3912 len += 1;
3913 }
3914 if self.asof_desc.is_some() {
3915 len += 1;
3916 }
3917 let mut struct_ser = serializer.serialize_struct("batch_plan.LocalLookupJoinNode", len)?;
3918 if self.join_type != 0 {
3919 let v = super::plan_common::JoinType::try_from(self.join_type)
3920 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3921 struct_ser.serialize_field("joinType", &v)?;
3922 }
3923 if let Some(v) = self.condition.as_ref() {
3924 struct_ser.serialize_field("condition", v)?;
3925 }
3926 if !self.outer_side_key.is_empty() {
3927 struct_ser.serialize_field("outerSideKey", &self.outer_side_key)?;
3928 }
3929 if !self.inner_side_key.is_empty() {
3930 struct_ser.serialize_field("innerSideKey", &self.inner_side_key)?;
3931 }
3932 if self.lookup_prefix_len != 0 {
3933 struct_ser.serialize_field("lookupPrefixLen", &self.lookup_prefix_len)?;
3934 }
3935 if let Some(v) = self.inner_side_table_desc.as_ref() {
3936 struct_ser.serialize_field("innerSideTableDesc", v)?;
3937 }
3938 if !self.inner_side_vnode_mapping.is_empty() {
3939 struct_ser.serialize_field("innerSideVnodeMapping", &self.inner_side_vnode_mapping.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3940 }
3941 if !self.inner_side_column_ids.is_empty() {
3942 struct_ser.serialize_field("innerSideColumnIds", &self.inner_side_column_ids)?;
3943 }
3944 if !self.output_indices.is_empty() {
3945 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3946 }
3947 if !self.worker_nodes.is_empty() {
3948 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
3949 }
3950 if !self.null_safe.is_empty() {
3951 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
3952 }
3953 if let Some(v) = self.as_of.as_ref() {
3954 struct_ser.serialize_field("asOf", v)?;
3955 }
3956 if let Some(v) = self.asof_desc.as_ref() {
3957 struct_ser.serialize_field("asofDesc", v)?;
3958 }
3959 struct_ser.end()
3960 }
3961}
3962impl<'de> serde::Deserialize<'de> for LocalLookupJoinNode {
3963 #[allow(deprecated)]
3964 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3965 where
3966 D: serde::Deserializer<'de>,
3967 {
3968 const FIELDS: &[&str] = &[
3969 "join_type",
3970 "joinType",
3971 "condition",
3972 "outer_side_key",
3973 "outerSideKey",
3974 "inner_side_key",
3975 "innerSideKey",
3976 "lookup_prefix_len",
3977 "lookupPrefixLen",
3978 "inner_side_table_desc",
3979 "innerSideTableDesc",
3980 "inner_side_vnode_mapping",
3981 "innerSideVnodeMapping",
3982 "inner_side_column_ids",
3983 "innerSideColumnIds",
3984 "output_indices",
3985 "outputIndices",
3986 "worker_nodes",
3987 "workerNodes",
3988 "null_safe",
3989 "nullSafe",
3990 "as_of",
3991 "asOf",
3992 "asof_desc",
3993 "asofDesc",
3994 ];
3995
3996 #[allow(clippy::enum_variant_names)]
3997 enum GeneratedField {
3998 JoinType,
3999 Condition,
4000 OuterSideKey,
4001 InnerSideKey,
4002 LookupPrefixLen,
4003 InnerSideTableDesc,
4004 InnerSideVnodeMapping,
4005 InnerSideColumnIds,
4006 OutputIndices,
4007 WorkerNodes,
4008 NullSafe,
4009 AsOf,
4010 AsofDesc,
4011 }
4012 impl<'de> serde::Deserialize<'de> for GeneratedField {
4013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4014 where
4015 D: serde::Deserializer<'de>,
4016 {
4017 struct GeneratedVisitor;
4018
4019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4020 type Value = GeneratedField;
4021
4022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4023 write!(formatter, "expected one of: {:?}", &FIELDS)
4024 }
4025
4026 #[allow(unused_variables)]
4027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4028 where
4029 E: serde::de::Error,
4030 {
4031 match value {
4032 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
4033 "condition" => Ok(GeneratedField::Condition),
4034 "outerSideKey" | "outer_side_key" => Ok(GeneratedField::OuterSideKey),
4035 "innerSideKey" | "inner_side_key" => Ok(GeneratedField::InnerSideKey),
4036 "lookupPrefixLen" | "lookup_prefix_len" => Ok(GeneratedField::LookupPrefixLen),
4037 "innerSideTableDesc" | "inner_side_table_desc" => Ok(GeneratedField::InnerSideTableDesc),
4038 "innerSideVnodeMapping" | "inner_side_vnode_mapping" => Ok(GeneratedField::InnerSideVnodeMapping),
4039 "innerSideColumnIds" | "inner_side_column_ids" => Ok(GeneratedField::InnerSideColumnIds),
4040 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
4041 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
4042 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
4043 "asOf" | "as_of" => Ok(GeneratedField::AsOf),
4044 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
4045 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4046 }
4047 }
4048 }
4049 deserializer.deserialize_identifier(GeneratedVisitor)
4050 }
4051 }
4052 struct GeneratedVisitor;
4053 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4054 type Value = LocalLookupJoinNode;
4055
4056 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4057 formatter.write_str("struct batch_plan.LocalLookupJoinNode")
4058 }
4059
4060 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalLookupJoinNode, V::Error>
4061 where
4062 V: serde::de::MapAccess<'de>,
4063 {
4064 let mut join_type__ = None;
4065 let mut condition__ = None;
4066 let mut outer_side_key__ = None;
4067 let mut inner_side_key__ = None;
4068 let mut lookup_prefix_len__ = None;
4069 let mut inner_side_table_desc__ = None;
4070 let mut inner_side_vnode_mapping__ = None;
4071 let mut inner_side_column_ids__ = None;
4072 let mut output_indices__ = None;
4073 let mut worker_nodes__ = None;
4074 let mut null_safe__ = None;
4075 let mut as_of__ = None;
4076 let mut asof_desc__ = None;
4077 while let Some(k) = map_.next_key()? {
4078 match k {
4079 GeneratedField::JoinType => {
4080 if join_type__.is_some() {
4081 return Err(serde::de::Error::duplicate_field("joinType"));
4082 }
4083 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
4084 }
4085 GeneratedField::Condition => {
4086 if condition__.is_some() {
4087 return Err(serde::de::Error::duplicate_field("condition"));
4088 }
4089 condition__ = map_.next_value()?;
4090 }
4091 GeneratedField::OuterSideKey => {
4092 if outer_side_key__.is_some() {
4093 return Err(serde::de::Error::duplicate_field("outerSideKey"));
4094 }
4095 outer_side_key__ =
4096 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4097 .into_iter().map(|x| x.0).collect())
4098 ;
4099 }
4100 GeneratedField::InnerSideKey => {
4101 if inner_side_key__.is_some() {
4102 return Err(serde::de::Error::duplicate_field("innerSideKey"));
4103 }
4104 inner_side_key__ =
4105 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4106 .into_iter().map(|x| x.0).collect())
4107 ;
4108 }
4109 GeneratedField::LookupPrefixLen => {
4110 if lookup_prefix_len__.is_some() {
4111 return Err(serde::de::Error::duplicate_field("lookupPrefixLen"));
4112 }
4113 lookup_prefix_len__ =
4114 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4115 ;
4116 }
4117 GeneratedField::InnerSideTableDesc => {
4118 if inner_side_table_desc__.is_some() {
4119 return Err(serde::de::Error::duplicate_field("innerSideTableDesc"));
4120 }
4121 inner_side_table_desc__ = map_.next_value()?;
4122 }
4123 GeneratedField::InnerSideVnodeMapping => {
4124 if inner_side_vnode_mapping__.is_some() {
4125 return Err(serde::de::Error::duplicate_field("innerSideVnodeMapping"));
4126 }
4127 inner_side_vnode_mapping__ =
4128 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4129 .into_iter().map(|x| x.0).collect())
4130 ;
4131 }
4132 GeneratedField::InnerSideColumnIds => {
4133 if inner_side_column_ids__.is_some() {
4134 return Err(serde::de::Error::duplicate_field("innerSideColumnIds"));
4135 }
4136 inner_side_column_ids__ =
4137 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4138 .into_iter().map(|x| x.0).collect())
4139 ;
4140 }
4141 GeneratedField::OutputIndices => {
4142 if output_indices__.is_some() {
4143 return Err(serde::de::Error::duplicate_field("outputIndices"));
4144 }
4145 output_indices__ =
4146 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4147 .into_iter().map(|x| x.0).collect())
4148 ;
4149 }
4150 GeneratedField::WorkerNodes => {
4151 if worker_nodes__.is_some() {
4152 return Err(serde::de::Error::duplicate_field("workerNodes"));
4153 }
4154 worker_nodes__ = Some(map_.next_value()?);
4155 }
4156 GeneratedField::NullSafe => {
4157 if null_safe__.is_some() {
4158 return Err(serde::de::Error::duplicate_field("nullSafe"));
4159 }
4160 null_safe__ = Some(map_.next_value()?);
4161 }
4162 GeneratedField::AsOf => {
4163 if as_of__.is_some() {
4164 return Err(serde::de::Error::duplicate_field("asOf"));
4165 }
4166 as_of__ = map_.next_value()?;
4167 }
4168 GeneratedField::AsofDesc => {
4169 if asof_desc__.is_some() {
4170 return Err(serde::de::Error::duplicate_field("asofDesc"));
4171 }
4172 asof_desc__ = map_.next_value()?;
4173 }
4174 }
4175 }
4176 Ok(LocalLookupJoinNode {
4177 join_type: join_type__.unwrap_or_default(),
4178 condition: condition__,
4179 outer_side_key: outer_side_key__.unwrap_or_default(),
4180 inner_side_key: inner_side_key__.unwrap_or_default(),
4181 lookup_prefix_len: lookup_prefix_len__.unwrap_or_default(),
4182 inner_side_table_desc: inner_side_table_desc__,
4183 inner_side_vnode_mapping: inner_side_vnode_mapping__.unwrap_or_default(),
4184 inner_side_column_ids: inner_side_column_ids__.unwrap_or_default(),
4185 output_indices: output_indices__.unwrap_or_default(),
4186 worker_nodes: worker_nodes__.unwrap_or_default(),
4187 null_safe: null_safe__.unwrap_or_default(),
4188 as_of: as_of__,
4189 asof_desc: asof_desc__,
4190 })
4191 }
4192 }
4193 deserializer.deserialize_struct("batch_plan.LocalLookupJoinNode", FIELDS, GeneratedVisitor)
4194 }
4195}
4196impl serde::Serialize for LogRowSeqScanNode {
4197 #[allow(deprecated)]
4198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4199 where
4200 S: serde::Serializer,
4201 {
4202 use serde::ser::SerializeStruct;
4203 let mut len = 0;
4204 if self.table_desc.is_some() {
4205 len += 1;
4206 }
4207 if !self.column_ids.is_empty() {
4208 len += 1;
4209 }
4210 if self.vnode_bitmap.is_some() {
4211 len += 1;
4212 }
4213 if self.old_epoch.is_some() {
4214 len += 1;
4215 }
4216 if self.new_epoch.is_some() {
4217 len += 1;
4218 }
4219 if self.ordered {
4220 len += 1;
4221 }
4222 if self.scan_range.is_some() {
4223 len += 1;
4224 }
4225 let mut struct_ser = serializer.serialize_struct("batch_plan.LogRowSeqScanNode", len)?;
4226 if let Some(v) = self.table_desc.as_ref() {
4227 struct_ser.serialize_field("tableDesc", v)?;
4228 }
4229 if !self.column_ids.is_empty() {
4230 struct_ser.serialize_field("columnIds", &self.column_ids)?;
4231 }
4232 if let Some(v) = self.vnode_bitmap.as_ref() {
4233 struct_ser.serialize_field("vnodeBitmap", v)?;
4234 }
4235 if let Some(v) = self.old_epoch.as_ref() {
4236 struct_ser.serialize_field("oldEpoch", v)?;
4237 }
4238 if let Some(v) = self.new_epoch.as_ref() {
4239 struct_ser.serialize_field("newEpoch", v)?;
4240 }
4241 if self.ordered {
4242 struct_ser.serialize_field("ordered", &self.ordered)?;
4243 }
4244 if let Some(v) = self.scan_range.as_ref() {
4245 struct_ser.serialize_field("scanRange", v)?;
4246 }
4247 struct_ser.end()
4248 }
4249}
4250impl<'de> serde::Deserialize<'de> for LogRowSeqScanNode {
4251 #[allow(deprecated)]
4252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4253 where
4254 D: serde::Deserializer<'de>,
4255 {
4256 const FIELDS: &[&str] = &[
4257 "table_desc",
4258 "tableDesc",
4259 "column_ids",
4260 "columnIds",
4261 "vnode_bitmap",
4262 "vnodeBitmap",
4263 "old_epoch",
4264 "oldEpoch",
4265 "new_epoch",
4266 "newEpoch",
4267 "ordered",
4268 "scan_range",
4269 "scanRange",
4270 ];
4271
4272 #[allow(clippy::enum_variant_names)]
4273 enum GeneratedField {
4274 TableDesc,
4275 ColumnIds,
4276 VnodeBitmap,
4277 OldEpoch,
4278 NewEpoch,
4279 Ordered,
4280 ScanRange,
4281 }
4282 impl<'de> serde::Deserialize<'de> for GeneratedField {
4283 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4284 where
4285 D: serde::Deserializer<'de>,
4286 {
4287 struct GeneratedVisitor;
4288
4289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4290 type Value = GeneratedField;
4291
4292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4293 write!(formatter, "expected one of: {:?}", &FIELDS)
4294 }
4295
4296 #[allow(unused_variables)]
4297 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4298 where
4299 E: serde::de::Error,
4300 {
4301 match value {
4302 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
4303 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
4304 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
4305 "oldEpoch" | "old_epoch" => Ok(GeneratedField::OldEpoch),
4306 "newEpoch" | "new_epoch" => Ok(GeneratedField::NewEpoch),
4307 "ordered" => Ok(GeneratedField::Ordered),
4308 "scanRange" | "scan_range" => Ok(GeneratedField::ScanRange),
4309 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4310 }
4311 }
4312 }
4313 deserializer.deserialize_identifier(GeneratedVisitor)
4314 }
4315 }
4316 struct GeneratedVisitor;
4317 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4318 type Value = LogRowSeqScanNode;
4319
4320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4321 formatter.write_str("struct batch_plan.LogRowSeqScanNode")
4322 }
4323
4324 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LogRowSeqScanNode, V::Error>
4325 where
4326 V: serde::de::MapAccess<'de>,
4327 {
4328 let mut table_desc__ = None;
4329 let mut column_ids__ = None;
4330 let mut vnode_bitmap__ = None;
4331 let mut old_epoch__ = None;
4332 let mut new_epoch__ = None;
4333 let mut ordered__ = None;
4334 let mut scan_range__ = None;
4335 while let Some(k) = map_.next_key()? {
4336 match k {
4337 GeneratedField::TableDesc => {
4338 if table_desc__.is_some() {
4339 return Err(serde::de::Error::duplicate_field("tableDesc"));
4340 }
4341 table_desc__ = map_.next_value()?;
4342 }
4343 GeneratedField::ColumnIds => {
4344 if column_ids__.is_some() {
4345 return Err(serde::de::Error::duplicate_field("columnIds"));
4346 }
4347 column_ids__ =
4348 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4349 .into_iter().map(|x| x.0).collect())
4350 ;
4351 }
4352 GeneratedField::VnodeBitmap => {
4353 if vnode_bitmap__.is_some() {
4354 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
4355 }
4356 vnode_bitmap__ = map_.next_value()?;
4357 }
4358 GeneratedField::OldEpoch => {
4359 if old_epoch__.is_some() {
4360 return Err(serde::de::Error::duplicate_field("oldEpoch"));
4361 }
4362 old_epoch__ = map_.next_value()?;
4363 }
4364 GeneratedField::NewEpoch => {
4365 if new_epoch__.is_some() {
4366 return Err(serde::de::Error::duplicate_field("newEpoch"));
4367 }
4368 new_epoch__ = map_.next_value()?;
4369 }
4370 GeneratedField::Ordered => {
4371 if ordered__.is_some() {
4372 return Err(serde::de::Error::duplicate_field("ordered"));
4373 }
4374 ordered__ = Some(map_.next_value()?);
4375 }
4376 GeneratedField::ScanRange => {
4377 if scan_range__.is_some() {
4378 return Err(serde::de::Error::duplicate_field("scanRange"));
4379 }
4380 scan_range__ = map_.next_value()?;
4381 }
4382 }
4383 }
4384 Ok(LogRowSeqScanNode {
4385 table_desc: table_desc__,
4386 column_ids: column_ids__.unwrap_or_default(),
4387 vnode_bitmap: vnode_bitmap__,
4388 old_epoch: old_epoch__,
4389 new_epoch: new_epoch__,
4390 ordered: ordered__.unwrap_or_default(),
4391 scan_range: scan_range__,
4392 })
4393 }
4394 }
4395 deserializer.deserialize_struct("batch_plan.LogRowSeqScanNode", FIELDS, GeneratedVisitor)
4396 }
4397}
4398impl serde::Serialize for MaxOneRowNode {
4399 #[allow(deprecated)]
4400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4401 where
4402 S: serde::Serializer,
4403 {
4404 use serde::ser::SerializeStruct;
4405 let len = 0;
4406 let struct_ser = serializer.serialize_struct("batch_plan.MaxOneRowNode", len)?;
4407 struct_ser.end()
4408 }
4409}
4410impl<'de> serde::Deserialize<'de> for MaxOneRowNode {
4411 #[allow(deprecated)]
4412 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4413 where
4414 D: serde::Deserializer<'de>,
4415 {
4416 const FIELDS: &[&str] = &[
4417 ];
4418
4419 #[allow(clippy::enum_variant_names)]
4420 enum GeneratedField {
4421 }
4422 impl<'de> serde::Deserialize<'de> for GeneratedField {
4423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4424 where
4425 D: serde::Deserializer<'de>,
4426 {
4427 struct GeneratedVisitor;
4428
4429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4430 type Value = GeneratedField;
4431
4432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4433 write!(formatter, "expected one of: {:?}", &FIELDS)
4434 }
4435
4436 #[allow(unused_variables)]
4437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4438 where
4439 E: serde::de::Error,
4440 {
4441 Err(serde::de::Error::unknown_field(value, FIELDS))
4442 }
4443 }
4444 deserializer.deserialize_identifier(GeneratedVisitor)
4445 }
4446 }
4447 struct GeneratedVisitor;
4448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4449 type Value = MaxOneRowNode;
4450
4451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4452 formatter.write_str("struct batch_plan.MaxOneRowNode")
4453 }
4454
4455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaxOneRowNode, V::Error>
4456 where
4457 V: serde::de::MapAccess<'de>,
4458 {
4459 while map_.next_key::<GeneratedField>()?.is_some() {
4460 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4461 }
4462 Ok(MaxOneRowNode {
4463 })
4464 }
4465 }
4466 deserializer.deserialize_struct("batch_plan.MaxOneRowNode", FIELDS, GeneratedVisitor)
4467 }
4468}
4469impl serde::Serialize for MergeSortExchangeNode {
4470 #[allow(deprecated)]
4471 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4472 where
4473 S: serde::Serializer,
4474 {
4475 use serde::ser::SerializeStruct;
4476 let mut len = 0;
4477 if self.exchange.is_some() {
4478 len += 1;
4479 }
4480 if !self.column_orders.is_empty() {
4481 len += 1;
4482 }
4483 let mut struct_ser = serializer.serialize_struct("batch_plan.MergeSortExchangeNode", len)?;
4484 if let Some(v) = self.exchange.as_ref() {
4485 struct_ser.serialize_field("exchange", v)?;
4486 }
4487 if !self.column_orders.is_empty() {
4488 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
4489 }
4490 struct_ser.end()
4491 }
4492}
4493impl<'de> serde::Deserialize<'de> for MergeSortExchangeNode {
4494 #[allow(deprecated)]
4495 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4496 where
4497 D: serde::Deserializer<'de>,
4498 {
4499 const FIELDS: &[&str] = &[
4500 "exchange",
4501 "column_orders",
4502 "columnOrders",
4503 ];
4504
4505 #[allow(clippy::enum_variant_names)]
4506 enum GeneratedField {
4507 Exchange,
4508 ColumnOrders,
4509 }
4510 impl<'de> serde::Deserialize<'de> for GeneratedField {
4511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4512 where
4513 D: serde::Deserializer<'de>,
4514 {
4515 struct GeneratedVisitor;
4516
4517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4518 type Value = GeneratedField;
4519
4520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4521 write!(formatter, "expected one of: {:?}", &FIELDS)
4522 }
4523
4524 #[allow(unused_variables)]
4525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4526 where
4527 E: serde::de::Error,
4528 {
4529 match value {
4530 "exchange" => Ok(GeneratedField::Exchange),
4531 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
4532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4533 }
4534 }
4535 }
4536 deserializer.deserialize_identifier(GeneratedVisitor)
4537 }
4538 }
4539 struct GeneratedVisitor;
4540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4541 type Value = MergeSortExchangeNode;
4542
4543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4544 formatter.write_str("struct batch_plan.MergeSortExchangeNode")
4545 }
4546
4547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeSortExchangeNode, V::Error>
4548 where
4549 V: serde::de::MapAccess<'de>,
4550 {
4551 let mut exchange__ = None;
4552 let mut column_orders__ = None;
4553 while let Some(k) = map_.next_key()? {
4554 match k {
4555 GeneratedField::Exchange => {
4556 if exchange__.is_some() {
4557 return Err(serde::de::Error::duplicate_field("exchange"));
4558 }
4559 exchange__ = map_.next_value()?;
4560 }
4561 GeneratedField::ColumnOrders => {
4562 if column_orders__.is_some() {
4563 return Err(serde::de::Error::duplicate_field("columnOrders"));
4564 }
4565 column_orders__ = Some(map_.next_value()?);
4566 }
4567 }
4568 }
4569 Ok(MergeSortExchangeNode {
4570 exchange: exchange__,
4571 column_orders: column_orders__.unwrap_or_default(),
4572 })
4573 }
4574 }
4575 deserializer.deserialize_struct("batch_plan.MergeSortExchangeNode", FIELDS, GeneratedVisitor)
4576 }
4577}
4578impl serde::Serialize for MySqlQueryNode {
4579 #[allow(deprecated)]
4580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4581 where
4582 S: serde::Serializer,
4583 {
4584 use serde::ser::SerializeStruct;
4585 let mut len = 0;
4586 if !self.columns.is_empty() {
4587 len += 1;
4588 }
4589 if !self.hostname.is_empty() {
4590 len += 1;
4591 }
4592 if !self.port.is_empty() {
4593 len += 1;
4594 }
4595 if !self.username.is_empty() {
4596 len += 1;
4597 }
4598 if !self.password.is_empty() {
4599 len += 1;
4600 }
4601 if !self.database.is_empty() {
4602 len += 1;
4603 }
4604 if !self.query.is_empty() {
4605 len += 1;
4606 }
4607 let mut struct_ser = serializer.serialize_struct("batch_plan.MySqlQueryNode", len)?;
4608 if !self.columns.is_empty() {
4609 struct_ser.serialize_field("columns", &self.columns)?;
4610 }
4611 if !self.hostname.is_empty() {
4612 struct_ser.serialize_field("hostname", &self.hostname)?;
4613 }
4614 if !self.port.is_empty() {
4615 struct_ser.serialize_field("port", &self.port)?;
4616 }
4617 if !self.username.is_empty() {
4618 struct_ser.serialize_field("username", &self.username)?;
4619 }
4620 if !self.password.is_empty() {
4621 struct_ser.serialize_field("password", &self.password)?;
4622 }
4623 if !self.database.is_empty() {
4624 struct_ser.serialize_field("database", &self.database)?;
4625 }
4626 if !self.query.is_empty() {
4627 struct_ser.serialize_field("query", &self.query)?;
4628 }
4629 struct_ser.end()
4630 }
4631}
4632impl<'de> serde::Deserialize<'de> for MySqlQueryNode {
4633 #[allow(deprecated)]
4634 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4635 where
4636 D: serde::Deserializer<'de>,
4637 {
4638 const FIELDS: &[&str] = &[
4639 "columns",
4640 "hostname",
4641 "port",
4642 "username",
4643 "password",
4644 "database",
4645 "query",
4646 ];
4647
4648 #[allow(clippy::enum_variant_names)]
4649 enum GeneratedField {
4650 Columns,
4651 Hostname,
4652 Port,
4653 Username,
4654 Password,
4655 Database,
4656 Query,
4657 }
4658 impl<'de> serde::Deserialize<'de> for GeneratedField {
4659 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4660 where
4661 D: serde::Deserializer<'de>,
4662 {
4663 struct GeneratedVisitor;
4664
4665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4666 type Value = GeneratedField;
4667
4668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4669 write!(formatter, "expected one of: {:?}", &FIELDS)
4670 }
4671
4672 #[allow(unused_variables)]
4673 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4674 where
4675 E: serde::de::Error,
4676 {
4677 match value {
4678 "columns" => Ok(GeneratedField::Columns),
4679 "hostname" => Ok(GeneratedField::Hostname),
4680 "port" => Ok(GeneratedField::Port),
4681 "username" => Ok(GeneratedField::Username),
4682 "password" => Ok(GeneratedField::Password),
4683 "database" => Ok(GeneratedField::Database),
4684 "query" => Ok(GeneratedField::Query),
4685 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4686 }
4687 }
4688 }
4689 deserializer.deserialize_identifier(GeneratedVisitor)
4690 }
4691 }
4692 struct GeneratedVisitor;
4693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4694 type Value = MySqlQueryNode;
4695
4696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4697 formatter.write_str("struct batch_plan.MySqlQueryNode")
4698 }
4699
4700 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MySqlQueryNode, V::Error>
4701 where
4702 V: serde::de::MapAccess<'de>,
4703 {
4704 let mut columns__ = None;
4705 let mut hostname__ = None;
4706 let mut port__ = None;
4707 let mut username__ = None;
4708 let mut password__ = None;
4709 let mut database__ = None;
4710 let mut query__ = None;
4711 while let Some(k) = map_.next_key()? {
4712 match k {
4713 GeneratedField::Columns => {
4714 if columns__.is_some() {
4715 return Err(serde::de::Error::duplicate_field("columns"));
4716 }
4717 columns__ = Some(map_.next_value()?);
4718 }
4719 GeneratedField::Hostname => {
4720 if hostname__.is_some() {
4721 return Err(serde::de::Error::duplicate_field("hostname"));
4722 }
4723 hostname__ = Some(map_.next_value()?);
4724 }
4725 GeneratedField::Port => {
4726 if port__.is_some() {
4727 return Err(serde::de::Error::duplicate_field("port"));
4728 }
4729 port__ = Some(map_.next_value()?);
4730 }
4731 GeneratedField::Username => {
4732 if username__.is_some() {
4733 return Err(serde::de::Error::duplicate_field("username"));
4734 }
4735 username__ = Some(map_.next_value()?);
4736 }
4737 GeneratedField::Password => {
4738 if password__.is_some() {
4739 return Err(serde::de::Error::duplicate_field("password"));
4740 }
4741 password__ = Some(map_.next_value()?);
4742 }
4743 GeneratedField::Database => {
4744 if database__.is_some() {
4745 return Err(serde::de::Error::duplicate_field("database"));
4746 }
4747 database__ = Some(map_.next_value()?);
4748 }
4749 GeneratedField::Query => {
4750 if query__.is_some() {
4751 return Err(serde::de::Error::duplicate_field("query"));
4752 }
4753 query__ = Some(map_.next_value()?);
4754 }
4755 }
4756 }
4757 Ok(MySqlQueryNode {
4758 columns: columns__.unwrap_or_default(),
4759 hostname: hostname__.unwrap_or_default(),
4760 port: port__.unwrap_or_default(),
4761 username: username__.unwrap_or_default(),
4762 password: password__.unwrap_or_default(),
4763 database: database__.unwrap_or_default(),
4764 query: query__.unwrap_or_default(),
4765 })
4766 }
4767 }
4768 deserializer.deserialize_struct("batch_plan.MySqlQueryNode", FIELDS, GeneratedVisitor)
4769 }
4770}
4771impl serde::Serialize for NestedLoopJoinNode {
4772 #[allow(deprecated)]
4773 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4774 where
4775 S: serde::Serializer,
4776 {
4777 use serde::ser::SerializeStruct;
4778 let mut len = 0;
4779 if self.join_type != 0 {
4780 len += 1;
4781 }
4782 if self.join_cond.is_some() {
4783 len += 1;
4784 }
4785 if !self.output_indices.is_empty() {
4786 len += 1;
4787 }
4788 let mut struct_ser = serializer.serialize_struct("batch_plan.NestedLoopJoinNode", len)?;
4789 if self.join_type != 0 {
4790 let v = super::plan_common::JoinType::try_from(self.join_type)
4791 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
4792 struct_ser.serialize_field("joinType", &v)?;
4793 }
4794 if let Some(v) = self.join_cond.as_ref() {
4795 struct_ser.serialize_field("joinCond", v)?;
4796 }
4797 if !self.output_indices.is_empty() {
4798 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
4799 }
4800 struct_ser.end()
4801 }
4802}
4803impl<'de> serde::Deserialize<'de> for NestedLoopJoinNode {
4804 #[allow(deprecated)]
4805 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4806 where
4807 D: serde::Deserializer<'de>,
4808 {
4809 const FIELDS: &[&str] = &[
4810 "join_type",
4811 "joinType",
4812 "join_cond",
4813 "joinCond",
4814 "output_indices",
4815 "outputIndices",
4816 ];
4817
4818 #[allow(clippy::enum_variant_names)]
4819 enum GeneratedField {
4820 JoinType,
4821 JoinCond,
4822 OutputIndices,
4823 }
4824 impl<'de> serde::Deserialize<'de> for GeneratedField {
4825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4826 where
4827 D: serde::Deserializer<'de>,
4828 {
4829 struct GeneratedVisitor;
4830
4831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4832 type Value = GeneratedField;
4833
4834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4835 write!(formatter, "expected one of: {:?}", &FIELDS)
4836 }
4837
4838 #[allow(unused_variables)]
4839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4840 where
4841 E: serde::de::Error,
4842 {
4843 match value {
4844 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
4845 "joinCond" | "join_cond" => Ok(GeneratedField::JoinCond),
4846 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
4847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4848 }
4849 }
4850 }
4851 deserializer.deserialize_identifier(GeneratedVisitor)
4852 }
4853 }
4854 struct GeneratedVisitor;
4855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4856 type Value = NestedLoopJoinNode;
4857
4858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4859 formatter.write_str("struct batch_plan.NestedLoopJoinNode")
4860 }
4861
4862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NestedLoopJoinNode, V::Error>
4863 where
4864 V: serde::de::MapAccess<'de>,
4865 {
4866 let mut join_type__ = None;
4867 let mut join_cond__ = None;
4868 let mut output_indices__ = None;
4869 while let Some(k) = map_.next_key()? {
4870 match k {
4871 GeneratedField::JoinType => {
4872 if join_type__.is_some() {
4873 return Err(serde::de::Error::duplicate_field("joinType"));
4874 }
4875 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
4876 }
4877 GeneratedField::JoinCond => {
4878 if join_cond__.is_some() {
4879 return Err(serde::de::Error::duplicate_field("joinCond"));
4880 }
4881 join_cond__ = map_.next_value()?;
4882 }
4883 GeneratedField::OutputIndices => {
4884 if output_indices__.is_some() {
4885 return Err(serde::de::Error::duplicate_field("outputIndices"));
4886 }
4887 output_indices__ =
4888 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4889 .into_iter().map(|x| x.0).collect())
4890 ;
4891 }
4892 }
4893 }
4894 Ok(NestedLoopJoinNode {
4895 join_type: join_type__.unwrap_or_default(),
4896 join_cond: join_cond__,
4897 output_indices: output_indices__.unwrap_or_default(),
4898 })
4899 }
4900 }
4901 deserializer.deserialize_struct("batch_plan.NestedLoopJoinNode", FIELDS, GeneratedVisitor)
4902 }
4903}
4904impl serde::Serialize for PlanFragment {
4905 #[allow(deprecated)]
4906 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4907 where
4908 S: serde::Serializer,
4909 {
4910 use serde::ser::SerializeStruct;
4911 let mut len = 0;
4912 if self.root.is_some() {
4913 len += 1;
4914 }
4915 if self.exchange_info.is_some() {
4916 len += 1;
4917 }
4918 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanFragment", len)?;
4919 if let Some(v) = self.root.as_ref() {
4920 struct_ser.serialize_field("root", v)?;
4921 }
4922 if let Some(v) = self.exchange_info.as_ref() {
4923 struct_ser.serialize_field("exchangeInfo", v)?;
4924 }
4925 struct_ser.end()
4926 }
4927}
4928impl<'de> serde::Deserialize<'de> for PlanFragment {
4929 #[allow(deprecated)]
4930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4931 where
4932 D: serde::Deserializer<'de>,
4933 {
4934 const FIELDS: &[&str] = &[
4935 "root",
4936 "exchange_info",
4937 "exchangeInfo",
4938 ];
4939
4940 #[allow(clippy::enum_variant_names)]
4941 enum GeneratedField {
4942 Root,
4943 ExchangeInfo,
4944 }
4945 impl<'de> serde::Deserialize<'de> for GeneratedField {
4946 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4947 where
4948 D: serde::Deserializer<'de>,
4949 {
4950 struct GeneratedVisitor;
4951
4952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4953 type Value = GeneratedField;
4954
4955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4956 write!(formatter, "expected one of: {:?}", &FIELDS)
4957 }
4958
4959 #[allow(unused_variables)]
4960 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4961 where
4962 E: serde::de::Error,
4963 {
4964 match value {
4965 "root" => Ok(GeneratedField::Root),
4966 "exchangeInfo" | "exchange_info" => Ok(GeneratedField::ExchangeInfo),
4967 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4968 }
4969 }
4970 }
4971 deserializer.deserialize_identifier(GeneratedVisitor)
4972 }
4973 }
4974 struct GeneratedVisitor;
4975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4976 type Value = PlanFragment;
4977
4978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4979 formatter.write_str("struct batch_plan.PlanFragment")
4980 }
4981
4982 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanFragment, V::Error>
4983 where
4984 V: serde::de::MapAccess<'de>,
4985 {
4986 let mut root__ = None;
4987 let mut exchange_info__ = None;
4988 while let Some(k) = map_.next_key()? {
4989 match k {
4990 GeneratedField::Root => {
4991 if root__.is_some() {
4992 return Err(serde::de::Error::duplicate_field("root"));
4993 }
4994 root__ = map_.next_value()?;
4995 }
4996 GeneratedField::ExchangeInfo => {
4997 if exchange_info__.is_some() {
4998 return Err(serde::de::Error::duplicate_field("exchangeInfo"));
4999 }
5000 exchange_info__ = map_.next_value()?;
5001 }
5002 }
5003 }
5004 Ok(PlanFragment {
5005 root: root__,
5006 exchange_info: exchange_info__,
5007 })
5008 }
5009 }
5010 deserializer.deserialize_struct("batch_plan.PlanFragment", FIELDS, GeneratedVisitor)
5011 }
5012}
5013impl serde::Serialize for PlanNode {
5014 #[allow(deprecated)]
5015 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5016 where
5017 S: serde::Serializer,
5018 {
5019 use serde::ser::SerializeStruct;
5020 let mut len = 0;
5021 if !self.children.is_empty() {
5022 len += 1;
5023 }
5024 if !self.identity.is_empty() {
5025 len += 1;
5026 }
5027 if self.node_body.is_some() {
5028 len += 1;
5029 }
5030 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanNode", len)?;
5031 if !self.children.is_empty() {
5032 struct_ser.serialize_field("children", &self.children)?;
5033 }
5034 if !self.identity.is_empty() {
5035 struct_ser.serialize_field("identity", &self.identity)?;
5036 }
5037 if let Some(v) = self.node_body.as_ref() {
5038 match v {
5039 plan_node::NodeBody::Insert(v) => {
5040 struct_ser.serialize_field("insert", v)?;
5041 }
5042 plan_node::NodeBody::Delete(v) => {
5043 struct_ser.serialize_field("delete", v)?;
5044 }
5045 plan_node::NodeBody::Update(v) => {
5046 struct_ser.serialize_field("update", v)?;
5047 }
5048 plan_node::NodeBody::Project(v) => {
5049 struct_ser.serialize_field("project", v)?;
5050 }
5051 plan_node::NodeBody::HashAgg(v) => {
5052 struct_ser.serialize_field("hashAgg", v)?;
5053 }
5054 plan_node::NodeBody::Filter(v) => {
5055 struct_ser.serialize_field("filter", v)?;
5056 }
5057 plan_node::NodeBody::Exchange(v) => {
5058 struct_ser.serialize_field("exchange", v)?;
5059 }
5060 plan_node::NodeBody::Sort(v) => {
5061 struct_ser.serialize_field("sort", v)?;
5062 }
5063 plan_node::NodeBody::NestedLoopJoin(v) => {
5064 struct_ser.serialize_field("nestedLoopJoin", v)?;
5065 }
5066 plan_node::NodeBody::TopN(v) => {
5067 struct_ser.serialize_field("topN", v)?;
5068 }
5069 plan_node::NodeBody::SortAgg(v) => {
5070 struct_ser.serialize_field("sortAgg", v)?;
5071 }
5072 plan_node::NodeBody::RowSeqScan(v) => {
5073 struct_ser.serialize_field("rowSeqScan", v)?;
5074 }
5075 plan_node::NodeBody::Limit(v) => {
5076 struct_ser.serialize_field("limit", v)?;
5077 }
5078 plan_node::NodeBody::Values(v) => {
5079 struct_ser.serialize_field("values", v)?;
5080 }
5081 plan_node::NodeBody::HashJoin(v) => {
5082 struct_ser.serialize_field("hashJoin", v)?;
5083 }
5084 plan_node::NodeBody::MergeSortExchange(v) => {
5085 struct_ser.serialize_field("mergeSortExchange", v)?;
5086 }
5087 plan_node::NodeBody::HopWindow(v) => {
5088 struct_ser.serialize_field("hopWindow", v)?;
5089 }
5090 plan_node::NodeBody::TableFunction(v) => {
5091 struct_ser.serialize_field("tableFunction", v)?;
5092 }
5093 plan_node::NodeBody::SysRowSeqScan(v) => {
5094 struct_ser.serialize_field("sysRowSeqScan", v)?;
5095 }
5096 plan_node::NodeBody::Expand(v) => {
5097 struct_ser.serialize_field("expand", v)?;
5098 }
5099 plan_node::NodeBody::LocalLookupJoin(v) => {
5100 struct_ser.serialize_field("localLookupJoin", v)?;
5101 }
5102 plan_node::NodeBody::ProjectSet(v) => {
5103 struct_ser.serialize_field("projectSet", v)?;
5104 }
5105 plan_node::NodeBody::Union(v) => {
5106 struct_ser.serialize_field("union", v)?;
5107 }
5108 plan_node::NodeBody::GroupTopN(v) => {
5109 struct_ser.serialize_field("groupTopN", v)?;
5110 }
5111 plan_node::NodeBody::DistributedLookupJoin(v) => {
5112 struct_ser.serialize_field("distributedLookupJoin", v)?;
5113 }
5114 plan_node::NodeBody::Source(v) => {
5115 struct_ser.serialize_field("source", v)?;
5116 }
5117 plan_node::NodeBody::SortOverWindow(v) => {
5118 struct_ser.serialize_field("sortOverWindow", v)?;
5119 }
5120 plan_node::NodeBody::MaxOneRow(v) => {
5121 struct_ser.serialize_field("maxOneRow", v)?;
5122 }
5123 plan_node::NodeBody::LogRowSeqScan(v) => {
5124 struct_ser.serialize_field("logRowSeqScan", v)?;
5125 }
5126 plan_node::NodeBody::FileScan(v) => {
5127 struct_ser.serialize_field("fileScan", v)?;
5128 }
5129 plan_node::NodeBody::IcebergScan(v) => {
5130 struct_ser.serialize_field("icebergScan", v)?;
5131 }
5132 plan_node::NodeBody::PostgresQuery(v) => {
5133 struct_ser.serialize_field("postgresQuery", v)?;
5134 }
5135 plan_node::NodeBody::MysqlQuery(v) => {
5136 struct_ser.serialize_field("mysqlQuery", v)?;
5137 }
5138 plan_node::NodeBody::GcsFileScan(v) => {
5139 struct_ser.serialize_field("gcsFileScan", v)?;
5140 }
5141 plan_node::NodeBody::AzblobFileScan(v) => {
5142 struct_ser.serialize_field("azblobFileScan", v)?;
5143 }
5144 plan_node::NodeBody::VectorIndexNearest(v) => {
5145 struct_ser.serialize_field("vectorIndexNearest", v)?;
5146 }
5147 plan_node::NodeBody::GetChannelDeltaStats(v) => {
5148 struct_ser.serialize_field("getChannelDeltaStats", v)?;
5149 }
5150 plan_node::NodeBody::BlockExecutor(v) => {
5151 struct_ser.serialize_field("blockExecutor", v)?;
5152 }
5153 plan_node::NodeBody::BusyLoopExecutor(v) => {
5154 struct_ser.serialize_field("busyLoopExecutor", v)?;
5155 }
5156 }
5157 }
5158 struct_ser.end()
5159 }
5160}
5161impl<'de> serde::Deserialize<'de> for PlanNode {
5162 #[allow(deprecated)]
5163 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5164 where
5165 D: serde::Deserializer<'de>,
5166 {
5167 const FIELDS: &[&str] = &[
5168 "children",
5169 "identity",
5170 "insert",
5171 "delete",
5172 "update",
5173 "project",
5174 "hash_agg",
5175 "hashAgg",
5176 "filter",
5177 "exchange",
5178 "sort",
5179 "nested_loop_join",
5180 "nestedLoopJoin",
5181 "top_n",
5182 "topN",
5183 "sort_agg",
5184 "sortAgg",
5185 "row_seq_scan",
5186 "rowSeqScan",
5187 "limit",
5188 "values",
5189 "hash_join",
5190 "hashJoin",
5191 "merge_sort_exchange",
5192 "mergeSortExchange",
5193 "hop_window",
5194 "hopWindow",
5195 "table_function",
5196 "tableFunction",
5197 "sys_row_seq_scan",
5198 "sysRowSeqScan",
5199 "expand",
5200 "local_lookup_join",
5201 "localLookupJoin",
5202 "project_set",
5203 "projectSet",
5204 "union",
5205 "group_top_n",
5206 "groupTopN",
5207 "distributed_lookup_join",
5208 "distributedLookupJoin",
5209 "source",
5210 "sort_over_window",
5211 "sortOverWindow",
5212 "max_one_row",
5213 "maxOneRow",
5214 "log_row_seq_scan",
5215 "logRowSeqScan",
5216 "file_scan",
5217 "fileScan",
5218 "iceberg_scan",
5219 "icebergScan",
5220 "postgres_query",
5221 "postgresQuery",
5222 "mysql_query",
5223 "mysqlQuery",
5224 "gcs_file_scan",
5225 "gcsFileScan",
5226 "azblob_file_scan",
5227 "azblobFileScan",
5228 "vector_index_nearest",
5229 "vectorIndexNearest",
5230 "get_channel_delta_stats",
5231 "getChannelDeltaStats",
5232 "block_executor",
5233 "blockExecutor",
5234 "busy_loop_executor",
5235 "busyLoopExecutor",
5236 ];
5237
5238 #[allow(clippy::enum_variant_names)]
5239 enum GeneratedField {
5240 Children,
5241 Identity,
5242 Insert,
5243 Delete,
5244 Update,
5245 Project,
5246 HashAgg,
5247 Filter,
5248 Exchange,
5249 Sort,
5250 NestedLoopJoin,
5251 TopN,
5252 SortAgg,
5253 RowSeqScan,
5254 Limit,
5255 Values,
5256 HashJoin,
5257 MergeSortExchange,
5258 HopWindow,
5259 TableFunction,
5260 SysRowSeqScan,
5261 Expand,
5262 LocalLookupJoin,
5263 ProjectSet,
5264 Union,
5265 GroupTopN,
5266 DistributedLookupJoin,
5267 Source,
5268 SortOverWindow,
5269 MaxOneRow,
5270 LogRowSeqScan,
5271 FileScan,
5272 IcebergScan,
5273 PostgresQuery,
5274 MysqlQuery,
5275 GcsFileScan,
5276 AzblobFileScan,
5277 VectorIndexNearest,
5278 GetChannelDeltaStats,
5279 BlockExecutor,
5280 BusyLoopExecutor,
5281 }
5282 impl<'de> serde::Deserialize<'de> for GeneratedField {
5283 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5284 where
5285 D: serde::Deserializer<'de>,
5286 {
5287 struct GeneratedVisitor;
5288
5289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5290 type Value = GeneratedField;
5291
5292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5293 write!(formatter, "expected one of: {:?}", &FIELDS)
5294 }
5295
5296 #[allow(unused_variables)]
5297 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5298 where
5299 E: serde::de::Error,
5300 {
5301 match value {
5302 "children" => Ok(GeneratedField::Children),
5303 "identity" => Ok(GeneratedField::Identity),
5304 "insert" => Ok(GeneratedField::Insert),
5305 "delete" => Ok(GeneratedField::Delete),
5306 "update" => Ok(GeneratedField::Update),
5307 "project" => Ok(GeneratedField::Project),
5308 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
5309 "filter" => Ok(GeneratedField::Filter),
5310 "exchange" => Ok(GeneratedField::Exchange),
5311 "sort" => Ok(GeneratedField::Sort),
5312 "nestedLoopJoin" | "nested_loop_join" => Ok(GeneratedField::NestedLoopJoin),
5313 "topN" | "top_n" => Ok(GeneratedField::TopN),
5314 "sortAgg" | "sort_agg" => Ok(GeneratedField::SortAgg),
5315 "rowSeqScan" | "row_seq_scan" => Ok(GeneratedField::RowSeqScan),
5316 "limit" => Ok(GeneratedField::Limit),
5317 "values" => Ok(GeneratedField::Values),
5318 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
5319 "mergeSortExchange" | "merge_sort_exchange" => Ok(GeneratedField::MergeSortExchange),
5320 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
5321 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
5322 "sysRowSeqScan" | "sys_row_seq_scan" => Ok(GeneratedField::SysRowSeqScan),
5323 "expand" => Ok(GeneratedField::Expand),
5324 "localLookupJoin" | "local_lookup_join" => Ok(GeneratedField::LocalLookupJoin),
5325 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
5326 "union" => Ok(GeneratedField::Union),
5327 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
5328 "distributedLookupJoin" | "distributed_lookup_join" => Ok(GeneratedField::DistributedLookupJoin),
5329 "source" => Ok(GeneratedField::Source),
5330 "sortOverWindow" | "sort_over_window" => Ok(GeneratedField::SortOverWindow),
5331 "maxOneRow" | "max_one_row" => Ok(GeneratedField::MaxOneRow),
5332 "logRowSeqScan" | "log_row_seq_scan" => Ok(GeneratedField::LogRowSeqScan),
5333 "fileScan" | "file_scan" => Ok(GeneratedField::FileScan),
5334 "icebergScan" | "iceberg_scan" => Ok(GeneratedField::IcebergScan),
5335 "postgresQuery" | "postgres_query" => Ok(GeneratedField::PostgresQuery),
5336 "mysqlQuery" | "mysql_query" => Ok(GeneratedField::MysqlQuery),
5337 "gcsFileScan" | "gcs_file_scan" => Ok(GeneratedField::GcsFileScan),
5338 "azblobFileScan" | "azblob_file_scan" => Ok(GeneratedField::AzblobFileScan),
5339 "vectorIndexNearest" | "vector_index_nearest" => Ok(GeneratedField::VectorIndexNearest),
5340 "getChannelDeltaStats" | "get_channel_delta_stats" => Ok(GeneratedField::GetChannelDeltaStats),
5341 "blockExecutor" | "block_executor" => Ok(GeneratedField::BlockExecutor),
5342 "busyLoopExecutor" | "busy_loop_executor" => Ok(GeneratedField::BusyLoopExecutor),
5343 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5344 }
5345 }
5346 }
5347 deserializer.deserialize_identifier(GeneratedVisitor)
5348 }
5349 }
5350 struct GeneratedVisitor;
5351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5352 type Value = PlanNode;
5353
5354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5355 formatter.write_str("struct batch_plan.PlanNode")
5356 }
5357
5358 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanNode, V::Error>
5359 where
5360 V: serde::de::MapAccess<'de>,
5361 {
5362 let mut children__ = None;
5363 let mut identity__ = None;
5364 let mut node_body__ = None;
5365 while let Some(k) = map_.next_key()? {
5366 match k {
5367 GeneratedField::Children => {
5368 if children__.is_some() {
5369 return Err(serde::de::Error::duplicate_field("children"));
5370 }
5371 children__ = Some(map_.next_value()?);
5372 }
5373 GeneratedField::Identity => {
5374 if identity__.is_some() {
5375 return Err(serde::de::Error::duplicate_field("identity"));
5376 }
5377 identity__ = Some(map_.next_value()?);
5378 }
5379 GeneratedField::Insert => {
5380 if node_body__.is_some() {
5381 return Err(serde::de::Error::duplicate_field("insert"));
5382 }
5383 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Insert)
5384;
5385 }
5386 GeneratedField::Delete => {
5387 if node_body__.is_some() {
5388 return Err(serde::de::Error::duplicate_field("delete"));
5389 }
5390 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Delete)
5391;
5392 }
5393 GeneratedField::Update => {
5394 if node_body__.is_some() {
5395 return Err(serde::de::Error::duplicate_field("update"));
5396 }
5397 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Update)
5398;
5399 }
5400 GeneratedField::Project => {
5401 if node_body__.is_some() {
5402 return Err(serde::de::Error::duplicate_field("project"));
5403 }
5404 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Project)
5405;
5406 }
5407 GeneratedField::HashAgg => {
5408 if node_body__.is_some() {
5409 return Err(serde::de::Error::duplicate_field("hashAgg"));
5410 }
5411 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashAgg)
5412;
5413 }
5414 GeneratedField::Filter => {
5415 if node_body__.is_some() {
5416 return Err(serde::de::Error::duplicate_field("filter"));
5417 }
5418 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Filter)
5419;
5420 }
5421 GeneratedField::Exchange => {
5422 if node_body__.is_some() {
5423 return Err(serde::de::Error::duplicate_field("exchange"));
5424 }
5425 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Exchange)
5426;
5427 }
5428 GeneratedField::Sort => {
5429 if node_body__.is_some() {
5430 return Err(serde::de::Error::duplicate_field("sort"));
5431 }
5432 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Sort)
5433;
5434 }
5435 GeneratedField::NestedLoopJoin => {
5436 if node_body__.is_some() {
5437 return Err(serde::de::Error::duplicate_field("nestedLoopJoin"));
5438 }
5439 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::NestedLoopJoin)
5440;
5441 }
5442 GeneratedField::TopN => {
5443 if node_body__.is_some() {
5444 return Err(serde::de::Error::duplicate_field("topN"));
5445 }
5446 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TopN)
5447;
5448 }
5449 GeneratedField::SortAgg => {
5450 if node_body__.is_some() {
5451 return Err(serde::de::Error::duplicate_field("sortAgg"));
5452 }
5453 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortAgg)
5454;
5455 }
5456 GeneratedField::RowSeqScan => {
5457 if node_body__.is_some() {
5458 return Err(serde::de::Error::duplicate_field("rowSeqScan"));
5459 }
5460 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::RowSeqScan)
5461;
5462 }
5463 GeneratedField::Limit => {
5464 if node_body__.is_some() {
5465 return Err(serde::de::Error::duplicate_field("limit"));
5466 }
5467 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Limit)
5468;
5469 }
5470 GeneratedField::Values => {
5471 if node_body__.is_some() {
5472 return Err(serde::de::Error::duplicate_field("values"));
5473 }
5474 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Values)
5475;
5476 }
5477 GeneratedField::HashJoin => {
5478 if node_body__.is_some() {
5479 return Err(serde::de::Error::duplicate_field("hashJoin"));
5480 }
5481 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashJoin)
5482;
5483 }
5484 GeneratedField::MergeSortExchange => {
5485 if node_body__.is_some() {
5486 return Err(serde::de::Error::duplicate_field("mergeSortExchange"));
5487 }
5488 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MergeSortExchange)
5489;
5490 }
5491 GeneratedField::HopWindow => {
5492 if node_body__.is_some() {
5493 return Err(serde::de::Error::duplicate_field("hopWindow"));
5494 }
5495 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HopWindow)
5496;
5497 }
5498 GeneratedField::TableFunction => {
5499 if node_body__.is_some() {
5500 return Err(serde::de::Error::duplicate_field("tableFunction"));
5501 }
5502 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TableFunction)
5503;
5504 }
5505 GeneratedField::SysRowSeqScan => {
5506 if node_body__.is_some() {
5507 return Err(serde::de::Error::duplicate_field("sysRowSeqScan"));
5508 }
5509 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SysRowSeqScan)
5510;
5511 }
5512 GeneratedField::Expand => {
5513 if node_body__.is_some() {
5514 return Err(serde::de::Error::duplicate_field("expand"));
5515 }
5516 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Expand)
5517;
5518 }
5519 GeneratedField::LocalLookupJoin => {
5520 if node_body__.is_some() {
5521 return Err(serde::de::Error::duplicate_field("localLookupJoin"));
5522 }
5523 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LocalLookupJoin)
5524;
5525 }
5526 GeneratedField::ProjectSet => {
5527 if node_body__.is_some() {
5528 return Err(serde::de::Error::duplicate_field("projectSet"));
5529 }
5530 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::ProjectSet)
5531;
5532 }
5533 GeneratedField::Union => {
5534 if node_body__.is_some() {
5535 return Err(serde::de::Error::duplicate_field("union"));
5536 }
5537 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Union)
5538;
5539 }
5540 GeneratedField::GroupTopN => {
5541 if node_body__.is_some() {
5542 return Err(serde::de::Error::duplicate_field("groupTopN"));
5543 }
5544 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GroupTopN)
5545;
5546 }
5547 GeneratedField::DistributedLookupJoin => {
5548 if node_body__.is_some() {
5549 return Err(serde::de::Error::duplicate_field("distributedLookupJoin"));
5550 }
5551 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::DistributedLookupJoin)
5552;
5553 }
5554 GeneratedField::Source => {
5555 if node_body__.is_some() {
5556 return Err(serde::de::Error::duplicate_field("source"));
5557 }
5558 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Source)
5559;
5560 }
5561 GeneratedField::SortOverWindow => {
5562 if node_body__.is_some() {
5563 return Err(serde::de::Error::duplicate_field("sortOverWindow"));
5564 }
5565 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortOverWindow)
5566;
5567 }
5568 GeneratedField::MaxOneRow => {
5569 if node_body__.is_some() {
5570 return Err(serde::de::Error::duplicate_field("maxOneRow"));
5571 }
5572 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MaxOneRow)
5573;
5574 }
5575 GeneratedField::LogRowSeqScan => {
5576 if node_body__.is_some() {
5577 return Err(serde::de::Error::duplicate_field("logRowSeqScan"));
5578 }
5579 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LogRowSeqScan)
5580;
5581 }
5582 GeneratedField::FileScan => {
5583 if node_body__.is_some() {
5584 return Err(serde::de::Error::duplicate_field("fileScan"));
5585 }
5586 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::FileScan)
5587;
5588 }
5589 GeneratedField::IcebergScan => {
5590 if node_body__.is_some() {
5591 return Err(serde::de::Error::duplicate_field("icebergScan"));
5592 }
5593 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergScan)
5594;
5595 }
5596 GeneratedField::PostgresQuery => {
5597 if node_body__.is_some() {
5598 return Err(serde::de::Error::duplicate_field("postgresQuery"));
5599 }
5600 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::PostgresQuery)
5601;
5602 }
5603 GeneratedField::MysqlQuery => {
5604 if node_body__.is_some() {
5605 return Err(serde::de::Error::duplicate_field("mysqlQuery"));
5606 }
5607 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MysqlQuery)
5608;
5609 }
5610 GeneratedField::GcsFileScan => {
5611 if node_body__.is_some() {
5612 return Err(serde::de::Error::duplicate_field("gcsFileScan"));
5613 }
5614 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GcsFileScan)
5615;
5616 }
5617 GeneratedField::AzblobFileScan => {
5618 if node_body__.is_some() {
5619 return Err(serde::de::Error::duplicate_field("azblobFileScan"));
5620 }
5621 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::AzblobFileScan)
5622;
5623 }
5624 GeneratedField::VectorIndexNearest => {
5625 if node_body__.is_some() {
5626 return Err(serde::de::Error::duplicate_field("vectorIndexNearest"));
5627 }
5628 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::VectorIndexNearest)
5629;
5630 }
5631 GeneratedField::GetChannelDeltaStats => {
5632 if node_body__.is_some() {
5633 return Err(serde::de::Error::duplicate_field("getChannelDeltaStats"));
5634 }
5635 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GetChannelDeltaStats)
5636;
5637 }
5638 GeneratedField::BlockExecutor => {
5639 if node_body__.is_some() {
5640 return Err(serde::de::Error::duplicate_field("blockExecutor"));
5641 }
5642 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BlockExecutor);
5643 }
5644 GeneratedField::BusyLoopExecutor => {
5645 if node_body__.is_some() {
5646 return Err(serde::de::Error::duplicate_field("busyLoopExecutor"));
5647 }
5648 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BusyLoopExecutor);
5649 }
5650 }
5651 }
5652 Ok(PlanNode {
5653 children: children__.unwrap_or_default(),
5654 identity: identity__.unwrap_or_default(),
5655 node_body: node_body__,
5656 })
5657 }
5658 }
5659 deserializer.deserialize_struct("batch_plan.PlanNode", FIELDS, GeneratedVisitor)
5660 }
5661}
5662impl serde::Serialize for PostgresQueryNode {
5663 #[allow(deprecated)]
5664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5665 where
5666 S: serde::Serializer,
5667 {
5668 use serde::ser::SerializeStruct;
5669 let mut len = 0;
5670 if !self.columns.is_empty() {
5671 len += 1;
5672 }
5673 if !self.hostname.is_empty() {
5674 len += 1;
5675 }
5676 if !self.port.is_empty() {
5677 len += 1;
5678 }
5679 if !self.username.is_empty() {
5680 len += 1;
5681 }
5682 if !self.password.is_empty() {
5683 len += 1;
5684 }
5685 if !self.database.is_empty() {
5686 len += 1;
5687 }
5688 if !self.query.is_empty() {
5689 len += 1;
5690 }
5691 let mut struct_ser = serializer.serialize_struct("batch_plan.PostgresQueryNode", len)?;
5692 if !self.columns.is_empty() {
5693 struct_ser.serialize_field("columns", &self.columns)?;
5694 }
5695 if !self.hostname.is_empty() {
5696 struct_ser.serialize_field("hostname", &self.hostname)?;
5697 }
5698 if !self.port.is_empty() {
5699 struct_ser.serialize_field("port", &self.port)?;
5700 }
5701 if !self.username.is_empty() {
5702 struct_ser.serialize_field("username", &self.username)?;
5703 }
5704 if !self.password.is_empty() {
5705 struct_ser.serialize_field("password", &self.password)?;
5706 }
5707 if !self.database.is_empty() {
5708 struct_ser.serialize_field("database", &self.database)?;
5709 }
5710 if !self.query.is_empty() {
5711 struct_ser.serialize_field("query", &self.query)?;
5712 }
5713 struct_ser.end()
5714 }
5715}
5716impl<'de> serde::Deserialize<'de> for PostgresQueryNode {
5717 #[allow(deprecated)]
5718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5719 where
5720 D: serde::Deserializer<'de>,
5721 {
5722 const FIELDS: &[&str] = &[
5723 "columns",
5724 "hostname",
5725 "port",
5726 "username",
5727 "password",
5728 "database",
5729 "query",
5730 ];
5731
5732 #[allow(clippy::enum_variant_names)]
5733 enum GeneratedField {
5734 Columns,
5735 Hostname,
5736 Port,
5737 Username,
5738 Password,
5739 Database,
5740 Query,
5741 }
5742 impl<'de> serde::Deserialize<'de> for GeneratedField {
5743 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5744 where
5745 D: serde::Deserializer<'de>,
5746 {
5747 struct GeneratedVisitor;
5748
5749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5750 type Value = GeneratedField;
5751
5752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5753 write!(formatter, "expected one of: {:?}", &FIELDS)
5754 }
5755
5756 #[allow(unused_variables)]
5757 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5758 where
5759 E: serde::de::Error,
5760 {
5761 match value {
5762 "columns" => Ok(GeneratedField::Columns),
5763 "hostname" => Ok(GeneratedField::Hostname),
5764 "port" => Ok(GeneratedField::Port),
5765 "username" => Ok(GeneratedField::Username),
5766 "password" => Ok(GeneratedField::Password),
5767 "database" => Ok(GeneratedField::Database),
5768 "query" => Ok(GeneratedField::Query),
5769 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5770 }
5771 }
5772 }
5773 deserializer.deserialize_identifier(GeneratedVisitor)
5774 }
5775 }
5776 struct GeneratedVisitor;
5777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5778 type Value = PostgresQueryNode;
5779
5780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5781 formatter.write_str("struct batch_plan.PostgresQueryNode")
5782 }
5783
5784 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PostgresQueryNode, V::Error>
5785 where
5786 V: serde::de::MapAccess<'de>,
5787 {
5788 let mut columns__ = None;
5789 let mut hostname__ = None;
5790 let mut port__ = None;
5791 let mut username__ = None;
5792 let mut password__ = None;
5793 let mut database__ = None;
5794 let mut query__ = None;
5795 while let Some(k) = map_.next_key()? {
5796 match k {
5797 GeneratedField::Columns => {
5798 if columns__.is_some() {
5799 return Err(serde::de::Error::duplicate_field("columns"));
5800 }
5801 columns__ = Some(map_.next_value()?);
5802 }
5803 GeneratedField::Hostname => {
5804 if hostname__.is_some() {
5805 return Err(serde::de::Error::duplicate_field("hostname"));
5806 }
5807 hostname__ = Some(map_.next_value()?);
5808 }
5809 GeneratedField::Port => {
5810 if port__.is_some() {
5811 return Err(serde::de::Error::duplicate_field("port"));
5812 }
5813 port__ = Some(map_.next_value()?);
5814 }
5815 GeneratedField::Username => {
5816 if username__.is_some() {
5817 return Err(serde::de::Error::duplicate_field("username"));
5818 }
5819 username__ = Some(map_.next_value()?);
5820 }
5821 GeneratedField::Password => {
5822 if password__.is_some() {
5823 return Err(serde::de::Error::duplicate_field("password"));
5824 }
5825 password__ = Some(map_.next_value()?);
5826 }
5827 GeneratedField::Database => {
5828 if database__.is_some() {
5829 return Err(serde::de::Error::duplicate_field("database"));
5830 }
5831 database__ = Some(map_.next_value()?);
5832 }
5833 GeneratedField::Query => {
5834 if query__.is_some() {
5835 return Err(serde::de::Error::duplicate_field("query"));
5836 }
5837 query__ = Some(map_.next_value()?);
5838 }
5839 }
5840 }
5841 Ok(PostgresQueryNode {
5842 columns: columns__.unwrap_or_default(),
5843 hostname: hostname__.unwrap_or_default(),
5844 port: port__.unwrap_or_default(),
5845 username: username__.unwrap_or_default(),
5846 password: password__.unwrap_or_default(),
5847 database: database__.unwrap_or_default(),
5848 query: query__.unwrap_or_default(),
5849 })
5850 }
5851 }
5852 deserializer.deserialize_struct("batch_plan.PostgresQueryNode", FIELDS, GeneratedVisitor)
5853 }
5854}
5855impl serde::Serialize for ProjectNode {
5856 #[allow(deprecated)]
5857 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5858 where
5859 S: serde::Serializer,
5860 {
5861 use serde::ser::SerializeStruct;
5862 let mut len = 0;
5863 if !self.select_list.is_empty() {
5864 len += 1;
5865 }
5866 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectNode", len)?;
5867 if !self.select_list.is_empty() {
5868 struct_ser.serialize_field("selectList", &self.select_list)?;
5869 }
5870 struct_ser.end()
5871 }
5872}
5873impl<'de> serde::Deserialize<'de> for ProjectNode {
5874 #[allow(deprecated)]
5875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5876 where
5877 D: serde::Deserializer<'de>,
5878 {
5879 const FIELDS: &[&str] = &[
5880 "select_list",
5881 "selectList",
5882 ];
5883
5884 #[allow(clippy::enum_variant_names)]
5885 enum GeneratedField {
5886 SelectList,
5887 }
5888 impl<'de> serde::Deserialize<'de> for GeneratedField {
5889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5890 where
5891 D: serde::Deserializer<'de>,
5892 {
5893 struct GeneratedVisitor;
5894
5895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5896 type Value = GeneratedField;
5897
5898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5899 write!(formatter, "expected one of: {:?}", &FIELDS)
5900 }
5901
5902 #[allow(unused_variables)]
5903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5904 where
5905 E: serde::de::Error,
5906 {
5907 match value {
5908 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5910 }
5911 }
5912 }
5913 deserializer.deserialize_identifier(GeneratedVisitor)
5914 }
5915 }
5916 struct GeneratedVisitor;
5917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5918 type Value = ProjectNode;
5919
5920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5921 formatter.write_str("struct batch_plan.ProjectNode")
5922 }
5923
5924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
5925 where
5926 V: serde::de::MapAccess<'de>,
5927 {
5928 let mut select_list__ = None;
5929 while let Some(k) = map_.next_key()? {
5930 match k {
5931 GeneratedField::SelectList => {
5932 if select_list__.is_some() {
5933 return Err(serde::de::Error::duplicate_field("selectList"));
5934 }
5935 select_list__ = Some(map_.next_value()?);
5936 }
5937 }
5938 }
5939 Ok(ProjectNode {
5940 select_list: select_list__.unwrap_or_default(),
5941 })
5942 }
5943 }
5944 deserializer.deserialize_struct("batch_plan.ProjectNode", FIELDS, GeneratedVisitor)
5945 }
5946}
5947impl serde::Serialize for ProjectSetNode {
5948 #[allow(deprecated)]
5949 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5950 where
5951 S: serde::Serializer,
5952 {
5953 use serde::ser::SerializeStruct;
5954 let mut len = 0;
5955 if !self.select_list.is_empty() {
5956 len += 1;
5957 }
5958 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectSetNode", len)?;
5959 if !self.select_list.is_empty() {
5960 struct_ser.serialize_field("selectList", &self.select_list)?;
5961 }
5962 struct_ser.end()
5963 }
5964}
5965impl<'de> serde::Deserialize<'de> for ProjectSetNode {
5966 #[allow(deprecated)]
5967 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5968 where
5969 D: serde::Deserializer<'de>,
5970 {
5971 const FIELDS: &[&str] = &[
5972 "select_list",
5973 "selectList",
5974 ];
5975
5976 #[allow(clippy::enum_variant_names)]
5977 enum GeneratedField {
5978 SelectList,
5979 }
5980 impl<'de> serde::Deserialize<'de> for GeneratedField {
5981 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5982 where
5983 D: serde::Deserializer<'de>,
5984 {
5985 struct GeneratedVisitor;
5986
5987 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5988 type Value = GeneratedField;
5989
5990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5991 write!(formatter, "expected one of: {:?}", &FIELDS)
5992 }
5993
5994 #[allow(unused_variables)]
5995 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5996 where
5997 E: serde::de::Error,
5998 {
5999 match value {
6000 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
6001 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6002 }
6003 }
6004 }
6005 deserializer.deserialize_identifier(GeneratedVisitor)
6006 }
6007 }
6008 struct GeneratedVisitor;
6009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6010 type Value = ProjectSetNode;
6011
6012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6013 formatter.write_str("struct batch_plan.ProjectSetNode")
6014 }
6015
6016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
6017 where
6018 V: serde::de::MapAccess<'de>,
6019 {
6020 let mut select_list__ = None;
6021 while let Some(k) = map_.next_key()? {
6022 match k {
6023 GeneratedField::SelectList => {
6024 if select_list__.is_some() {
6025 return Err(serde::de::Error::duplicate_field("selectList"));
6026 }
6027 select_list__ = Some(map_.next_value()?);
6028 }
6029 }
6030 }
6031 Ok(ProjectSetNode {
6032 select_list: select_list__.unwrap_or_default(),
6033 })
6034 }
6035 }
6036 deserializer.deserialize_struct("batch_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
6037 }
6038}
6039impl serde::Serialize for RowSeqScanNode {
6040 #[allow(deprecated)]
6041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6042 where
6043 S: serde::Serializer,
6044 {
6045 use serde::ser::SerializeStruct;
6046 let mut len = 0;
6047 if self.table_desc.is_some() {
6048 len += 1;
6049 }
6050 if !self.column_ids.is_empty() {
6051 len += 1;
6052 }
6053 if !self.scan_ranges.is_empty() {
6054 len += 1;
6055 }
6056 if self.vnode_bitmap.is_some() {
6057 len += 1;
6058 }
6059 if self.ordered {
6060 len += 1;
6061 }
6062 if self.limit.is_some() {
6063 len += 1;
6064 }
6065 if self.as_of.is_some() {
6066 len += 1;
6067 }
6068 let mut struct_ser = serializer.serialize_struct("batch_plan.RowSeqScanNode", len)?;
6069 if let Some(v) = self.table_desc.as_ref() {
6070 struct_ser.serialize_field("tableDesc", v)?;
6071 }
6072 if !self.column_ids.is_empty() {
6073 struct_ser.serialize_field("columnIds", &self.column_ids)?;
6074 }
6075 if !self.scan_ranges.is_empty() {
6076 struct_ser.serialize_field("scanRanges", &self.scan_ranges)?;
6077 }
6078 if let Some(v) = self.vnode_bitmap.as_ref() {
6079 struct_ser.serialize_field("vnodeBitmap", v)?;
6080 }
6081 if self.ordered {
6082 struct_ser.serialize_field("ordered", &self.ordered)?;
6083 }
6084 if let Some(v) = self.limit.as_ref() {
6085 #[allow(clippy::needless_borrow)]
6086 #[allow(clippy::needless_borrows_for_generic_args)]
6087 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
6088 }
6089 if let Some(v) = self.as_of.as_ref() {
6090 struct_ser.serialize_field("asOf", v)?;
6091 }
6092 struct_ser.end()
6093 }
6094}
6095impl<'de> serde::Deserialize<'de> for RowSeqScanNode {
6096 #[allow(deprecated)]
6097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6098 where
6099 D: serde::Deserializer<'de>,
6100 {
6101 const FIELDS: &[&str] = &[
6102 "table_desc",
6103 "tableDesc",
6104 "column_ids",
6105 "columnIds",
6106 "scan_ranges",
6107 "scanRanges",
6108 "vnode_bitmap",
6109 "vnodeBitmap",
6110 "ordered",
6111 "limit",
6112 "as_of",
6113 "asOf",
6114 ];
6115
6116 #[allow(clippy::enum_variant_names)]
6117 enum GeneratedField {
6118 TableDesc,
6119 ColumnIds,
6120 ScanRanges,
6121 VnodeBitmap,
6122 Ordered,
6123 Limit,
6124 AsOf,
6125 }
6126 impl<'de> serde::Deserialize<'de> for GeneratedField {
6127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6128 where
6129 D: serde::Deserializer<'de>,
6130 {
6131 struct GeneratedVisitor;
6132
6133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6134 type Value = GeneratedField;
6135
6136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6137 write!(formatter, "expected one of: {:?}", &FIELDS)
6138 }
6139
6140 #[allow(unused_variables)]
6141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6142 where
6143 E: serde::de::Error,
6144 {
6145 match value {
6146 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
6147 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
6148 "scanRanges" | "scan_ranges" => Ok(GeneratedField::ScanRanges),
6149 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
6150 "ordered" => Ok(GeneratedField::Ordered),
6151 "limit" => Ok(GeneratedField::Limit),
6152 "asOf" | "as_of" => Ok(GeneratedField::AsOf),
6153 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6154 }
6155 }
6156 }
6157 deserializer.deserialize_identifier(GeneratedVisitor)
6158 }
6159 }
6160 struct GeneratedVisitor;
6161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6162 type Value = RowSeqScanNode;
6163
6164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6165 formatter.write_str("struct batch_plan.RowSeqScanNode")
6166 }
6167
6168 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowSeqScanNode, V::Error>
6169 where
6170 V: serde::de::MapAccess<'de>,
6171 {
6172 let mut table_desc__ = None;
6173 let mut column_ids__ = None;
6174 let mut scan_ranges__ = None;
6175 let mut vnode_bitmap__ = None;
6176 let mut ordered__ = None;
6177 let mut limit__ = None;
6178 let mut as_of__ = None;
6179 while let Some(k) = map_.next_key()? {
6180 match k {
6181 GeneratedField::TableDesc => {
6182 if table_desc__.is_some() {
6183 return Err(serde::de::Error::duplicate_field("tableDesc"));
6184 }
6185 table_desc__ = map_.next_value()?;
6186 }
6187 GeneratedField::ColumnIds => {
6188 if column_ids__.is_some() {
6189 return Err(serde::de::Error::duplicate_field("columnIds"));
6190 }
6191 column_ids__ =
6192 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6193 .into_iter().map(|x| x.0).collect())
6194 ;
6195 }
6196 GeneratedField::ScanRanges => {
6197 if scan_ranges__.is_some() {
6198 return Err(serde::de::Error::duplicate_field("scanRanges"));
6199 }
6200 scan_ranges__ = Some(map_.next_value()?);
6201 }
6202 GeneratedField::VnodeBitmap => {
6203 if vnode_bitmap__.is_some() {
6204 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
6205 }
6206 vnode_bitmap__ = map_.next_value()?;
6207 }
6208 GeneratedField::Ordered => {
6209 if ordered__.is_some() {
6210 return Err(serde::de::Error::duplicate_field("ordered"));
6211 }
6212 ordered__ = Some(map_.next_value()?);
6213 }
6214 GeneratedField::Limit => {
6215 if limit__.is_some() {
6216 return Err(serde::de::Error::duplicate_field("limit"));
6217 }
6218 limit__ =
6219 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6220 ;
6221 }
6222 GeneratedField::AsOf => {
6223 if as_of__.is_some() {
6224 return Err(serde::de::Error::duplicate_field("asOf"));
6225 }
6226 as_of__ = map_.next_value()?;
6227 }
6228 }
6229 }
6230 Ok(RowSeqScanNode {
6231 table_desc: table_desc__,
6232 column_ids: column_ids__.unwrap_or_default(),
6233 scan_ranges: scan_ranges__.unwrap_or_default(),
6234 vnode_bitmap: vnode_bitmap__,
6235 ordered: ordered__.unwrap_or_default(),
6236 limit: limit__,
6237 as_of: as_of__,
6238 })
6239 }
6240 }
6241 deserializer.deserialize_struct("batch_plan.RowSeqScanNode", FIELDS, GeneratedVisitor)
6242 }
6243}
6244impl serde::Serialize for ScanRange {
6245 #[allow(deprecated)]
6246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6247 where
6248 S: serde::Serializer,
6249 {
6250 use serde::ser::SerializeStruct;
6251 let mut len = 0;
6252 if !self.eq_conds.is_empty() {
6253 len += 1;
6254 }
6255 if self.lower_bound.is_some() {
6256 len += 1;
6257 }
6258 if self.upper_bound.is_some() {
6259 len += 1;
6260 }
6261 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange", len)?;
6262 if !self.eq_conds.is_empty() {
6263 struct_ser.serialize_field("eqConds", &self.eq_conds.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6264 }
6265 if let Some(v) = self.lower_bound.as_ref() {
6266 struct_ser.serialize_field("lowerBound", v)?;
6267 }
6268 if let Some(v) = self.upper_bound.as_ref() {
6269 struct_ser.serialize_field("upperBound", v)?;
6270 }
6271 struct_ser.end()
6272 }
6273}
6274impl<'de> serde::Deserialize<'de> for ScanRange {
6275 #[allow(deprecated)]
6276 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6277 where
6278 D: serde::Deserializer<'de>,
6279 {
6280 const FIELDS: &[&str] = &[
6281 "eq_conds",
6282 "eqConds",
6283 "lower_bound",
6284 "lowerBound",
6285 "upper_bound",
6286 "upperBound",
6287 ];
6288
6289 #[allow(clippy::enum_variant_names)]
6290 enum GeneratedField {
6291 EqConds,
6292 LowerBound,
6293 UpperBound,
6294 }
6295 impl<'de> serde::Deserialize<'de> for GeneratedField {
6296 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6297 where
6298 D: serde::Deserializer<'de>,
6299 {
6300 struct GeneratedVisitor;
6301
6302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6303 type Value = GeneratedField;
6304
6305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6306 write!(formatter, "expected one of: {:?}", &FIELDS)
6307 }
6308
6309 #[allow(unused_variables)]
6310 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6311 where
6312 E: serde::de::Error,
6313 {
6314 match value {
6315 "eqConds" | "eq_conds" => Ok(GeneratedField::EqConds),
6316 "lowerBound" | "lower_bound" => Ok(GeneratedField::LowerBound),
6317 "upperBound" | "upper_bound" => Ok(GeneratedField::UpperBound),
6318 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6319 }
6320 }
6321 }
6322 deserializer.deserialize_identifier(GeneratedVisitor)
6323 }
6324 }
6325 struct GeneratedVisitor;
6326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6327 type Value = ScanRange;
6328
6329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6330 formatter.write_str("struct batch_plan.ScanRange")
6331 }
6332
6333 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScanRange, V::Error>
6334 where
6335 V: serde::de::MapAccess<'de>,
6336 {
6337 let mut eq_conds__ = None;
6338 let mut lower_bound__ = None;
6339 let mut upper_bound__ = None;
6340 while let Some(k) = map_.next_key()? {
6341 match k {
6342 GeneratedField::EqConds => {
6343 if eq_conds__.is_some() {
6344 return Err(serde::de::Error::duplicate_field("eqConds"));
6345 }
6346 eq_conds__ =
6347 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6348 .into_iter().map(|x| x.0).collect())
6349 ;
6350 }
6351 GeneratedField::LowerBound => {
6352 if lower_bound__.is_some() {
6353 return Err(serde::de::Error::duplicate_field("lowerBound"));
6354 }
6355 lower_bound__ = map_.next_value()?;
6356 }
6357 GeneratedField::UpperBound => {
6358 if upper_bound__.is_some() {
6359 return Err(serde::de::Error::duplicate_field("upperBound"));
6360 }
6361 upper_bound__ = map_.next_value()?;
6362 }
6363 }
6364 }
6365 Ok(ScanRange {
6366 eq_conds: eq_conds__.unwrap_or_default(),
6367 lower_bound: lower_bound__,
6368 upper_bound: upper_bound__,
6369 })
6370 }
6371 }
6372 deserializer.deserialize_struct("batch_plan.ScanRange", FIELDS, GeneratedVisitor)
6373 }
6374}
6375impl serde::Serialize for scan_range::Bound {
6376 #[allow(deprecated)]
6377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6378 where
6379 S: serde::Serializer,
6380 {
6381 use serde::ser::SerializeStruct;
6382 let mut len = 0;
6383 if !self.value.is_empty() {
6384 len += 1;
6385 }
6386 if self.inclusive {
6387 len += 1;
6388 }
6389 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange.Bound", len)?;
6390 if !self.value.is_empty() {
6391 struct_ser.serialize_field("value", &self.value.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6392 }
6393 if self.inclusive {
6394 struct_ser.serialize_field("inclusive", &self.inclusive)?;
6395 }
6396 struct_ser.end()
6397 }
6398}
6399impl<'de> serde::Deserialize<'de> for scan_range::Bound {
6400 #[allow(deprecated)]
6401 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6402 where
6403 D: serde::Deserializer<'de>,
6404 {
6405 const FIELDS: &[&str] = &[
6406 "value",
6407 "inclusive",
6408 ];
6409
6410 #[allow(clippy::enum_variant_names)]
6411 enum GeneratedField {
6412 Value,
6413 Inclusive,
6414 }
6415 impl<'de> serde::Deserialize<'de> for GeneratedField {
6416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6417 where
6418 D: serde::Deserializer<'de>,
6419 {
6420 struct GeneratedVisitor;
6421
6422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6423 type Value = GeneratedField;
6424
6425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6426 write!(formatter, "expected one of: {:?}", &FIELDS)
6427 }
6428
6429 #[allow(unused_variables)]
6430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6431 where
6432 E: serde::de::Error,
6433 {
6434 match value {
6435 "value" => Ok(GeneratedField::Value),
6436 "inclusive" => Ok(GeneratedField::Inclusive),
6437 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6438 }
6439 }
6440 }
6441 deserializer.deserialize_identifier(GeneratedVisitor)
6442 }
6443 }
6444 struct GeneratedVisitor;
6445 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6446 type Value = scan_range::Bound;
6447
6448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6449 formatter.write_str("struct batch_plan.ScanRange.Bound")
6450 }
6451
6452 fn visit_map<V>(self, mut map_: V) -> std::result::Result<scan_range::Bound, V::Error>
6453 where
6454 V: serde::de::MapAccess<'de>,
6455 {
6456 let mut value__ = None;
6457 let mut inclusive__ = None;
6458 while let Some(k) = map_.next_key()? {
6459 match k {
6460 GeneratedField::Value => {
6461 if value__.is_some() {
6462 return Err(serde::de::Error::duplicate_field("value"));
6463 }
6464 value__ =
6465 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6466 .into_iter().map(|x| x.0).collect())
6467 ;
6468 }
6469 GeneratedField::Inclusive => {
6470 if inclusive__.is_some() {
6471 return Err(serde::de::Error::duplicate_field("inclusive"));
6472 }
6473 inclusive__ = Some(map_.next_value()?);
6474 }
6475 }
6476 }
6477 Ok(scan_range::Bound {
6478 value: value__.unwrap_or_default(),
6479 inclusive: inclusive__.unwrap_or_default(),
6480 })
6481 }
6482 }
6483 deserializer.deserialize_struct("batch_plan.ScanRange.Bound", FIELDS, GeneratedVisitor)
6484 }
6485}
6486impl serde::Serialize for SortAggNode {
6487 #[allow(deprecated)]
6488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6489 where
6490 S: serde::Serializer,
6491 {
6492 use serde::ser::SerializeStruct;
6493 let mut len = 0;
6494 if !self.group_key.is_empty() {
6495 len += 1;
6496 }
6497 if !self.agg_calls.is_empty() {
6498 len += 1;
6499 }
6500 let mut struct_ser = serializer.serialize_struct("batch_plan.SortAggNode", len)?;
6501 if !self.group_key.is_empty() {
6502 struct_ser.serialize_field("groupKey", &self.group_key)?;
6503 }
6504 if !self.agg_calls.is_empty() {
6505 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6506 }
6507 struct_ser.end()
6508 }
6509}
6510impl<'de> serde::Deserialize<'de> for SortAggNode {
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 "group_key",
6518 "groupKey",
6519 "agg_calls",
6520 "aggCalls",
6521 ];
6522
6523 #[allow(clippy::enum_variant_names)]
6524 enum GeneratedField {
6525 GroupKey,
6526 AggCalls,
6527 }
6528 impl<'de> serde::Deserialize<'de> for GeneratedField {
6529 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6530 where
6531 D: serde::Deserializer<'de>,
6532 {
6533 struct GeneratedVisitor;
6534
6535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6536 type Value = GeneratedField;
6537
6538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6539 write!(formatter, "expected one of: {:?}", &FIELDS)
6540 }
6541
6542 #[allow(unused_variables)]
6543 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6544 where
6545 E: serde::de::Error,
6546 {
6547 match value {
6548 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6549 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6551 }
6552 }
6553 }
6554 deserializer.deserialize_identifier(GeneratedVisitor)
6555 }
6556 }
6557 struct GeneratedVisitor;
6558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6559 type Value = SortAggNode;
6560
6561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6562 formatter.write_str("struct batch_plan.SortAggNode")
6563 }
6564
6565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortAggNode, V::Error>
6566 where
6567 V: serde::de::MapAccess<'de>,
6568 {
6569 let mut group_key__ = None;
6570 let mut agg_calls__ = None;
6571 while let Some(k) = map_.next_key()? {
6572 match k {
6573 GeneratedField::GroupKey => {
6574 if group_key__.is_some() {
6575 return Err(serde::de::Error::duplicate_field("groupKey"));
6576 }
6577 group_key__ = Some(map_.next_value()?);
6578 }
6579 GeneratedField::AggCalls => {
6580 if agg_calls__.is_some() {
6581 return Err(serde::de::Error::duplicate_field("aggCalls"));
6582 }
6583 agg_calls__ = Some(map_.next_value()?);
6584 }
6585 }
6586 }
6587 Ok(SortAggNode {
6588 group_key: group_key__.unwrap_or_default(),
6589 agg_calls: agg_calls__.unwrap_or_default(),
6590 })
6591 }
6592 }
6593 deserializer.deserialize_struct("batch_plan.SortAggNode", FIELDS, GeneratedVisitor)
6594 }
6595}
6596impl serde::Serialize for SortMergeJoinNode {
6597 #[allow(deprecated)]
6598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6599 where
6600 S: serde::Serializer,
6601 {
6602 use serde::ser::SerializeStruct;
6603 let mut len = 0;
6604 if self.join_type != 0 {
6605 len += 1;
6606 }
6607 if !self.left_key.is_empty() {
6608 len += 1;
6609 }
6610 if !self.right_key.is_empty() {
6611 len += 1;
6612 }
6613 if self.direction != 0 {
6614 len += 1;
6615 }
6616 if !self.output_indices.is_empty() {
6617 len += 1;
6618 }
6619 let mut struct_ser = serializer.serialize_struct("batch_plan.SortMergeJoinNode", len)?;
6620 if self.join_type != 0 {
6621 let v = super::plan_common::JoinType::try_from(self.join_type)
6622 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6623 struct_ser.serialize_field("joinType", &v)?;
6624 }
6625 if !self.left_key.is_empty() {
6626 struct_ser.serialize_field("leftKey", &self.left_key)?;
6627 }
6628 if !self.right_key.is_empty() {
6629 struct_ser.serialize_field("rightKey", &self.right_key)?;
6630 }
6631 if self.direction != 0 {
6632 let v = super::common::Direction::try_from(self.direction)
6633 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
6634 struct_ser.serialize_field("direction", &v)?;
6635 }
6636 if !self.output_indices.is_empty() {
6637 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6638 }
6639 struct_ser.end()
6640 }
6641}
6642impl<'de> serde::Deserialize<'de> for SortMergeJoinNode {
6643 #[allow(deprecated)]
6644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6645 where
6646 D: serde::Deserializer<'de>,
6647 {
6648 const FIELDS: &[&str] = &[
6649 "join_type",
6650 "joinType",
6651 "left_key",
6652 "leftKey",
6653 "right_key",
6654 "rightKey",
6655 "direction",
6656 "output_indices",
6657 "outputIndices",
6658 ];
6659
6660 #[allow(clippy::enum_variant_names)]
6661 enum GeneratedField {
6662 JoinType,
6663 LeftKey,
6664 RightKey,
6665 Direction,
6666 OutputIndices,
6667 }
6668 impl<'de> serde::Deserialize<'de> for GeneratedField {
6669 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6670 where
6671 D: serde::Deserializer<'de>,
6672 {
6673 struct GeneratedVisitor;
6674
6675 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6676 type Value = GeneratedField;
6677
6678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6679 write!(formatter, "expected one of: {:?}", &FIELDS)
6680 }
6681
6682 #[allow(unused_variables)]
6683 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6684 where
6685 E: serde::de::Error,
6686 {
6687 match value {
6688 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6689 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6690 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6691 "direction" => Ok(GeneratedField::Direction),
6692 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6693 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6694 }
6695 }
6696 }
6697 deserializer.deserialize_identifier(GeneratedVisitor)
6698 }
6699 }
6700 struct GeneratedVisitor;
6701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6702 type Value = SortMergeJoinNode;
6703
6704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6705 formatter.write_str("struct batch_plan.SortMergeJoinNode")
6706 }
6707
6708 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortMergeJoinNode, V::Error>
6709 where
6710 V: serde::de::MapAccess<'de>,
6711 {
6712 let mut join_type__ = None;
6713 let mut left_key__ = None;
6714 let mut right_key__ = None;
6715 let mut direction__ = None;
6716 let mut output_indices__ = None;
6717 while let Some(k) = map_.next_key()? {
6718 match k {
6719 GeneratedField::JoinType => {
6720 if join_type__.is_some() {
6721 return Err(serde::de::Error::duplicate_field("joinType"));
6722 }
6723 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6724 }
6725 GeneratedField::LeftKey => {
6726 if left_key__.is_some() {
6727 return Err(serde::de::Error::duplicate_field("leftKey"));
6728 }
6729 left_key__ =
6730 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6731 .into_iter().map(|x| x.0).collect())
6732 ;
6733 }
6734 GeneratedField::RightKey => {
6735 if right_key__.is_some() {
6736 return Err(serde::de::Error::duplicate_field("rightKey"));
6737 }
6738 right_key__ =
6739 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6740 .into_iter().map(|x| x.0).collect())
6741 ;
6742 }
6743 GeneratedField::Direction => {
6744 if direction__.is_some() {
6745 return Err(serde::de::Error::duplicate_field("direction"));
6746 }
6747 direction__ = Some(map_.next_value::<super::common::Direction>()? as i32);
6748 }
6749 GeneratedField::OutputIndices => {
6750 if output_indices__.is_some() {
6751 return Err(serde::de::Error::duplicate_field("outputIndices"));
6752 }
6753 output_indices__ =
6754 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6755 .into_iter().map(|x| x.0).collect())
6756 ;
6757 }
6758 }
6759 }
6760 Ok(SortMergeJoinNode {
6761 join_type: join_type__.unwrap_or_default(),
6762 left_key: left_key__.unwrap_or_default(),
6763 right_key: right_key__.unwrap_or_default(),
6764 direction: direction__.unwrap_or_default(),
6765 output_indices: output_indices__.unwrap_or_default(),
6766 })
6767 }
6768 }
6769 deserializer.deserialize_struct("batch_plan.SortMergeJoinNode", FIELDS, GeneratedVisitor)
6770 }
6771}
6772impl serde::Serialize for SortNode {
6773 #[allow(deprecated)]
6774 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6775 where
6776 S: serde::Serializer,
6777 {
6778 use serde::ser::SerializeStruct;
6779 let mut len = 0;
6780 if !self.column_orders.is_empty() {
6781 len += 1;
6782 }
6783 let mut struct_ser = serializer.serialize_struct("batch_plan.SortNode", len)?;
6784 if !self.column_orders.is_empty() {
6785 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6786 }
6787 struct_ser.end()
6788 }
6789}
6790impl<'de> serde::Deserialize<'de> for SortNode {
6791 #[allow(deprecated)]
6792 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6793 where
6794 D: serde::Deserializer<'de>,
6795 {
6796 const FIELDS: &[&str] = &[
6797 "column_orders",
6798 "columnOrders",
6799 ];
6800
6801 #[allow(clippy::enum_variant_names)]
6802 enum GeneratedField {
6803 ColumnOrders,
6804 }
6805 impl<'de> serde::Deserialize<'de> for GeneratedField {
6806 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6807 where
6808 D: serde::Deserializer<'de>,
6809 {
6810 struct GeneratedVisitor;
6811
6812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6813 type Value = GeneratedField;
6814
6815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6816 write!(formatter, "expected one of: {:?}", &FIELDS)
6817 }
6818
6819 #[allow(unused_variables)]
6820 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6821 where
6822 E: serde::de::Error,
6823 {
6824 match value {
6825 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6826 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6827 }
6828 }
6829 }
6830 deserializer.deserialize_identifier(GeneratedVisitor)
6831 }
6832 }
6833 struct GeneratedVisitor;
6834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6835 type Value = SortNode;
6836
6837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6838 formatter.write_str("struct batch_plan.SortNode")
6839 }
6840
6841 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
6842 where
6843 V: serde::de::MapAccess<'de>,
6844 {
6845 let mut column_orders__ = None;
6846 while let Some(k) = map_.next_key()? {
6847 match k {
6848 GeneratedField::ColumnOrders => {
6849 if column_orders__.is_some() {
6850 return Err(serde::de::Error::duplicate_field("columnOrders"));
6851 }
6852 column_orders__ = Some(map_.next_value()?);
6853 }
6854 }
6855 }
6856 Ok(SortNode {
6857 column_orders: column_orders__.unwrap_or_default(),
6858 })
6859 }
6860 }
6861 deserializer.deserialize_struct("batch_plan.SortNode", FIELDS, GeneratedVisitor)
6862 }
6863}
6864impl serde::Serialize for SortOverWindowNode {
6865 #[allow(deprecated)]
6866 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6867 where
6868 S: serde::Serializer,
6869 {
6870 use serde::ser::SerializeStruct;
6871 let mut len = 0;
6872 if !self.calls.is_empty() {
6873 len += 1;
6874 }
6875 if !self.partition_by.is_empty() {
6876 len += 1;
6877 }
6878 if !self.order_by.is_empty() {
6879 len += 1;
6880 }
6881 let mut struct_ser = serializer.serialize_struct("batch_plan.SortOverWindowNode", len)?;
6882 if !self.calls.is_empty() {
6883 struct_ser.serialize_field("calls", &self.calls)?;
6884 }
6885 if !self.partition_by.is_empty() {
6886 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
6887 }
6888 if !self.order_by.is_empty() {
6889 struct_ser.serialize_field("orderBy", &self.order_by)?;
6890 }
6891 struct_ser.end()
6892 }
6893}
6894impl<'de> serde::Deserialize<'de> for SortOverWindowNode {
6895 #[allow(deprecated)]
6896 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6897 where
6898 D: serde::Deserializer<'de>,
6899 {
6900 const FIELDS: &[&str] = &[
6901 "calls",
6902 "partition_by",
6903 "partitionBy",
6904 "order_by",
6905 "orderBy",
6906 ];
6907
6908 #[allow(clippy::enum_variant_names)]
6909 enum GeneratedField {
6910 Calls,
6911 PartitionBy,
6912 OrderBy,
6913 }
6914 impl<'de> serde::Deserialize<'de> for GeneratedField {
6915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6916 where
6917 D: serde::Deserializer<'de>,
6918 {
6919 struct GeneratedVisitor;
6920
6921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6922 type Value = GeneratedField;
6923
6924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6925 write!(formatter, "expected one of: {:?}", &FIELDS)
6926 }
6927
6928 #[allow(unused_variables)]
6929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6930 where
6931 E: serde::de::Error,
6932 {
6933 match value {
6934 "calls" => Ok(GeneratedField::Calls),
6935 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
6936 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
6937 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6938 }
6939 }
6940 }
6941 deserializer.deserialize_identifier(GeneratedVisitor)
6942 }
6943 }
6944 struct GeneratedVisitor;
6945 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6946 type Value = SortOverWindowNode;
6947
6948 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6949 formatter.write_str("struct batch_plan.SortOverWindowNode")
6950 }
6951
6952 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortOverWindowNode, V::Error>
6953 where
6954 V: serde::de::MapAccess<'de>,
6955 {
6956 let mut calls__ = None;
6957 let mut partition_by__ = None;
6958 let mut order_by__ = None;
6959 while let Some(k) = map_.next_key()? {
6960 match k {
6961 GeneratedField::Calls => {
6962 if calls__.is_some() {
6963 return Err(serde::de::Error::duplicate_field("calls"));
6964 }
6965 calls__ = Some(map_.next_value()?);
6966 }
6967 GeneratedField::PartitionBy => {
6968 if partition_by__.is_some() {
6969 return Err(serde::de::Error::duplicate_field("partitionBy"));
6970 }
6971 partition_by__ =
6972 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6973 .into_iter().map(|x| x.0).collect())
6974 ;
6975 }
6976 GeneratedField::OrderBy => {
6977 if order_by__.is_some() {
6978 return Err(serde::de::Error::duplicate_field("orderBy"));
6979 }
6980 order_by__ = Some(map_.next_value()?);
6981 }
6982 }
6983 }
6984 Ok(SortOverWindowNode {
6985 calls: calls__.unwrap_or_default(),
6986 partition_by: partition_by__.unwrap_or_default(),
6987 order_by: order_by__.unwrap_or_default(),
6988 })
6989 }
6990 }
6991 deserializer.deserialize_struct("batch_plan.SortOverWindowNode", FIELDS, GeneratedVisitor)
6992 }
6993}
6994impl serde::Serialize for SourceNode {
6995 #[allow(deprecated)]
6996 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6997 where
6998 S: serde::Serializer,
6999 {
7000 use serde::ser::SerializeStruct;
7001 let mut len = 0;
7002 if self.source_id != 0 {
7003 len += 1;
7004 }
7005 if !self.columns.is_empty() {
7006 len += 1;
7007 }
7008 if !self.with_properties.is_empty() {
7009 len += 1;
7010 }
7011 if !self.split.is_empty() {
7012 len += 1;
7013 }
7014 if self.info.is_some() {
7015 len += 1;
7016 }
7017 if !self.secret_refs.is_empty() {
7018 len += 1;
7019 }
7020 let mut struct_ser = serializer.serialize_struct("batch_plan.SourceNode", len)?;
7021 if self.source_id != 0 {
7022 struct_ser.serialize_field("sourceId", &self.source_id)?;
7023 }
7024 if !self.columns.is_empty() {
7025 struct_ser.serialize_field("columns", &self.columns)?;
7026 }
7027 if !self.with_properties.is_empty() {
7028 struct_ser.serialize_field("withProperties", &self.with_properties)?;
7029 }
7030 if !self.split.is_empty() {
7031 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
7032 }
7033 if let Some(v) = self.info.as_ref() {
7034 struct_ser.serialize_field("info", v)?;
7035 }
7036 if !self.secret_refs.is_empty() {
7037 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
7038 }
7039 struct_ser.end()
7040 }
7041}
7042impl<'de> serde::Deserialize<'de> for SourceNode {
7043 #[allow(deprecated)]
7044 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7045 where
7046 D: serde::Deserializer<'de>,
7047 {
7048 const FIELDS: &[&str] = &[
7049 "source_id",
7050 "sourceId",
7051 "columns",
7052 "with_properties",
7053 "withProperties",
7054 "split",
7055 "info",
7056 "secret_refs",
7057 "secretRefs",
7058 ];
7059
7060 #[allow(clippy::enum_variant_names)]
7061 enum GeneratedField {
7062 SourceId,
7063 Columns,
7064 WithProperties,
7065 Split,
7066 Info,
7067 SecretRefs,
7068 }
7069 impl<'de> serde::Deserialize<'de> for GeneratedField {
7070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7071 where
7072 D: serde::Deserializer<'de>,
7073 {
7074 struct GeneratedVisitor;
7075
7076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7077 type Value = GeneratedField;
7078
7079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7080 write!(formatter, "expected one of: {:?}", &FIELDS)
7081 }
7082
7083 #[allow(unused_variables)]
7084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7085 where
7086 E: serde::de::Error,
7087 {
7088 match value {
7089 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7090 "columns" => Ok(GeneratedField::Columns),
7091 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
7092 "split" => Ok(GeneratedField::Split),
7093 "info" => Ok(GeneratedField::Info),
7094 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
7095 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7096 }
7097 }
7098 }
7099 deserializer.deserialize_identifier(GeneratedVisitor)
7100 }
7101 }
7102 struct GeneratedVisitor;
7103 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7104 type Value = SourceNode;
7105
7106 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7107 formatter.write_str("struct batch_plan.SourceNode")
7108 }
7109
7110 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
7111 where
7112 V: serde::de::MapAccess<'de>,
7113 {
7114 let mut source_id__ = None;
7115 let mut columns__ = None;
7116 let mut with_properties__ = None;
7117 let mut split__ = None;
7118 let mut info__ = None;
7119 let mut secret_refs__ = None;
7120 while let Some(k) = map_.next_key()? {
7121 match k {
7122 GeneratedField::SourceId => {
7123 if source_id__.is_some() {
7124 return Err(serde::de::Error::duplicate_field("sourceId"));
7125 }
7126 source_id__ =
7127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7128 ;
7129 }
7130 GeneratedField::Columns => {
7131 if columns__.is_some() {
7132 return Err(serde::de::Error::duplicate_field("columns"));
7133 }
7134 columns__ = Some(map_.next_value()?);
7135 }
7136 GeneratedField::WithProperties => {
7137 if with_properties__.is_some() {
7138 return Err(serde::de::Error::duplicate_field("withProperties"));
7139 }
7140 with_properties__ = Some(
7141 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7142 );
7143 }
7144 GeneratedField::Split => {
7145 if split__.is_some() {
7146 return Err(serde::de::Error::duplicate_field("split"));
7147 }
7148 split__ =
7149 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7150 .into_iter().map(|x| x.0).collect())
7151 ;
7152 }
7153 GeneratedField::Info => {
7154 if info__.is_some() {
7155 return Err(serde::de::Error::duplicate_field("info"));
7156 }
7157 info__ = map_.next_value()?;
7158 }
7159 GeneratedField::SecretRefs => {
7160 if secret_refs__.is_some() {
7161 return Err(serde::de::Error::duplicate_field("secretRefs"));
7162 }
7163 secret_refs__ = Some(
7164 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7165 );
7166 }
7167 }
7168 }
7169 Ok(SourceNode {
7170 source_id: source_id__.unwrap_or_default(),
7171 columns: columns__.unwrap_or_default(),
7172 with_properties: with_properties__.unwrap_or_default(),
7173 split: split__.unwrap_or_default(),
7174 info: info__,
7175 secret_refs: secret_refs__.unwrap_or_default(),
7176 })
7177 }
7178 }
7179 deserializer.deserialize_struct("batch_plan.SourceNode", FIELDS, GeneratedVisitor)
7180 }
7181}
7182impl serde::Serialize for SysRowSeqScanNode {
7183 #[allow(deprecated)]
7184 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7185 where
7186 S: serde::Serializer,
7187 {
7188 use serde::ser::SerializeStruct;
7189 let mut len = 0;
7190 if self.table_id != 0 {
7191 len += 1;
7192 }
7193 if !self.column_descs.is_empty() {
7194 len += 1;
7195 }
7196 let mut struct_ser = serializer.serialize_struct("batch_plan.SysRowSeqScanNode", len)?;
7197 if self.table_id != 0 {
7198 struct_ser.serialize_field("tableId", &self.table_id)?;
7199 }
7200 if !self.column_descs.is_empty() {
7201 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
7202 }
7203 struct_ser.end()
7204 }
7205}
7206impl<'de> serde::Deserialize<'de> for SysRowSeqScanNode {
7207 #[allow(deprecated)]
7208 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7209 where
7210 D: serde::Deserializer<'de>,
7211 {
7212 const FIELDS: &[&str] = &[
7213 "table_id",
7214 "tableId",
7215 "column_descs",
7216 "columnDescs",
7217 ];
7218
7219 #[allow(clippy::enum_variant_names)]
7220 enum GeneratedField {
7221 TableId,
7222 ColumnDescs,
7223 }
7224 impl<'de> serde::Deserialize<'de> for GeneratedField {
7225 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7226 where
7227 D: serde::Deserializer<'de>,
7228 {
7229 struct GeneratedVisitor;
7230
7231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7232 type Value = GeneratedField;
7233
7234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7235 write!(formatter, "expected one of: {:?}", &FIELDS)
7236 }
7237
7238 #[allow(unused_variables)]
7239 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7240 where
7241 E: serde::de::Error,
7242 {
7243 match value {
7244 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7245 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
7246 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7247 }
7248 }
7249 }
7250 deserializer.deserialize_identifier(GeneratedVisitor)
7251 }
7252 }
7253 struct GeneratedVisitor;
7254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7255 type Value = SysRowSeqScanNode;
7256
7257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7258 formatter.write_str("struct batch_plan.SysRowSeqScanNode")
7259 }
7260
7261 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SysRowSeqScanNode, V::Error>
7262 where
7263 V: serde::de::MapAccess<'de>,
7264 {
7265 let mut table_id__ = None;
7266 let mut column_descs__ = None;
7267 while let Some(k) = map_.next_key()? {
7268 match k {
7269 GeneratedField::TableId => {
7270 if table_id__.is_some() {
7271 return Err(serde::de::Error::duplicate_field("tableId"));
7272 }
7273 table_id__ =
7274 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7275 ;
7276 }
7277 GeneratedField::ColumnDescs => {
7278 if column_descs__.is_some() {
7279 return Err(serde::de::Error::duplicate_field("columnDescs"));
7280 }
7281 column_descs__ = Some(map_.next_value()?);
7282 }
7283 }
7284 }
7285 Ok(SysRowSeqScanNode {
7286 table_id: table_id__.unwrap_or_default(),
7287 column_descs: column_descs__.unwrap_or_default(),
7288 })
7289 }
7290 }
7291 deserializer.deserialize_struct("batch_plan.SysRowSeqScanNode", FIELDS, GeneratedVisitor)
7292 }
7293}
7294impl serde::Serialize for TableFunctionNode {
7295 #[allow(deprecated)]
7296 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7297 where
7298 S: serde::Serializer,
7299 {
7300 use serde::ser::SerializeStruct;
7301 let mut len = 0;
7302 if self.table_function.is_some() {
7303 len += 1;
7304 }
7305 let mut struct_ser = serializer.serialize_struct("batch_plan.TableFunctionNode", len)?;
7306 if let Some(v) = self.table_function.as_ref() {
7307 struct_ser.serialize_field("tableFunction", v)?;
7308 }
7309 struct_ser.end()
7310 }
7311}
7312impl<'de> serde::Deserialize<'de> for TableFunctionNode {
7313 #[allow(deprecated)]
7314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7315 where
7316 D: serde::Deserializer<'de>,
7317 {
7318 const FIELDS: &[&str] = &[
7319 "table_function",
7320 "tableFunction",
7321 ];
7322
7323 #[allow(clippy::enum_variant_names)]
7324 enum GeneratedField {
7325 TableFunction,
7326 }
7327 impl<'de> serde::Deserialize<'de> for GeneratedField {
7328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7329 where
7330 D: serde::Deserializer<'de>,
7331 {
7332 struct GeneratedVisitor;
7333
7334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7335 type Value = GeneratedField;
7336
7337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7338 write!(formatter, "expected one of: {:?}", &FIELDS)
7339 }
7340
7341 #[allow(unused_variables)]
7342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7343 where
7344 E: serde::de::Error,
7345 {
7346 match value {
7347 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
7348 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7349 }
7350 }
7351 }
7352 deserializer.deserialize_identifier(GeneratedVisitor)
7353 }
7354 }
7355 struct GeneratedVisitor;
7356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7357 type Value = TableFunctionNode;
7358
7359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7360 formatter.write_str("struct batch_plan.TableFunctionNode")
7361 }
7362
7363 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunctionNode, V::Error>
7364 where
7365 V: serde::de::MapAccess<'de>,
7366 {
7367 let mut table_function__ = None;
7368 while let Some(k) = map_.next_key()? {
7369 match k {
7370 GeneratedField::TableFunction => {
7371 if table_function__.is_some() {
7372 return Err(serde::de::Error::duplicate_field("tableFunction"));
7373 }
7374 table_function__ = map_.next_value()?;
7375 }
7376 }
7377 }
7378 Ok(TableFunctionNode {
7379 table_function: table_function__,
7380 })
7381 }
7382 }
7383 deserializer.deserialize_struct("batch_plan.TableFunctionNode", FIELDS, GeneratedVisitor)
7384 }
7385}
7386impl serde::Serialize for TaskId {
7387 #[allow(deprecated)]
7388 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7389 where
7390 S: serde::Serializer,
7391 {
7392 use serde::ser::SerializeStruct;
7393 let mut len = 0;
7394 if !self.query_id.is_empty() {
7395 len += 1;
7396 }
7397 if self.stage_id != 0 {
7398 len += 1;
7399 }
7400 if self.task_id != 0 {
7401 len += 1;
7402 }
7403 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskId", len)?;
7404 if !self.query_id.is_empty() {
7405 struct_ser.serialize_field("queryId", &self.query_id)?;
7406 }
7407 if self.stage_id != 0 {
7408 struct_ser.serialize_field("stageId", &self.stage_id)?;
7409 }
7410 if self.task_id != 0 {
7411 #[allow(clippy::needless_borrow)]
7412 #[allow(clippy::needless_borrows_for_generic_args)]
7413 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7414 }
7415 struct_ser.end()
7416 }
7417}
7418impl<'de> serde::Deserialize<'de> for TaskId {
7419 #[allow(deprecated)]
7420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7421 where
7422 D: serde::Deserializer<'de>,
7423 {
7424 const FIELDS: &[&str] = &[
7425 "query_id",
7426 "queryId",
7427 "stage_id",
7428 "stageId",
7429 "task_id",
7430 "taskId",
7431 ];
7432
7433 #[allow(clippy::enum_variant_names)]
7434 enum GeneratedField {
7435 QueryId,
7436 StageId,
7437 TaskId,
7438 }
7439 impl<'de> serde::Deserialize<'de> for GeneratedField {
7440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7441 where
7442 D: serde::Deserializer<'de>,
7443 {
7444 struct GeneratedVisitor;
7445
7446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7447 type Value = GeneratedField;
7448
7449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7450 write!(formatter, "expected one of: {:?}", &FIELDS)
7451 }
7452
7453 #[allow(unused_variables)]
7454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7455 where
7456 E: serde::de::Error,
7457 {
7458 match value {
7459 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
7460 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
7461 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7462 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7463 }
7464 }
7465 }
7466 deserializer.deserialize_identifier(GeneratedVisitor)
7467 }
7468 }
7469 struct GeneratedVisitor;
7470 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7471 type Value = TaskId;
7472
7473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7474 formatter.write_str("struct batch_plan.TaskId")
7475 }
7476
7477 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
7478 where
7479 V: serde::de::MapAccess<'de>,
7480 {
7481 let mut query_id__ = None;
7482 let mut stage_id__ = None;
7483 let mut task_id__ = None;
7484 while let Some(k) = map_.next_key()? {
7485 match k {
7486 GeneratedField::QueryId => {
7487 if query_id__.is_some() {
7488 return Err(serde::de::Error::duplicate_field("queryId"));
7489 }
7490 query_id__ = Some(map_.next_value()?);
7491 }
7492 GeneratedField::StageId => {
7493 if stage_id__.is_some() {
7494 return Err(serde::de::Error::duplicate_field("stageId"));
7495 }
7496 stage_id__ =
7497 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7498 ;
7499 }
7500 GeneratedField::TaskId => {
7501 if task_id__.is_some() {
7502 return Err(serde::de::Error::duplicate_field("taskId"));
7503 }
7504 task_id__ =
7505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7506 ;
7507 }
7508 }
7509 }
7510 Ok(TaskId {
7511 query_id: query_id__.unwrap_or_default(),
7512 stage_id: stage_id__.unwrap_or_default(),
7513 task_id: task_id__.unwrap_or_default(),
7514 })
7515 }
7516 }
7517 deserializer.deserialize_struct("batch_plan.TaskId", FIELDS, GeneratedVisitor)
7518 }
7519}
7520impl serde::Serialize for TaskOutputId {
7521 #[allow(deprecated)]
7522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7523 where
7524 S: serde::Serializer,
7525 {
7526 use serde::ser::SerializeStruct;
7527 let mut len = 0;
7528 if self.task_id.is_some() {
7529 len += 1;
7530 }
7531 if self.output_id != 0 {
7532 len += 1;
7533 }
7534 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskOutputId", len)?;
7535 if let Some(v) = self.task_id.as_ref() {
7536 struct_ser.serialize_field("taskId", v)?;
7537 }
7538 if self.output_id != 0 {
7539 #[allow(clippy::needless_borrow)]
7540 #[allow(clippy::needless_borrows_for_generic_args)]
7541 struct_ser.serialize_field("outputId", ToString::to_string(&self.output_id).as_str())?;
7542 }
7543 struct_ser.end()
7544 }
7545}
7546impl<'de> serde::Deserialize<'de> for TaskOutputId {
7547 #[allow(deprecated)]
7548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7549 where
7550 D: serde::Deserializer<'de>,
7551 {
7552 const FIELDS: &[&str] = &[
7553 "task_id",
7554 "taskId",
7555 "output_id",
7556 "outputId",
7557 ];
7558
7559 #[allow(clippy::enum_variant_names)]
7560 enum GeneratedField {
7561 TaskId,
7562 OutputId,
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 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7585 "outputId" | "output_id" => Ok(GeneratedField::OutputId),
7586 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7587 }
7588 }
7589 }
7590 deserializer.deserialize_identifier(GeneratedVisitor)
7591 }
7592 }
7593 struct GeneratedVisitor;
7594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7595 type Value = TaskOutputId;
7596
7597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7598 formatter.write_str("struct batch_plan.TaskOutputId")
7599 }
7600
7601 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskOutputId, V::Error>
7602 where
7603 V: serde::de::MapAccess<'de>,
7604 {
7605 let mut task_id__ = None;
7606 let mut output_id__ = None;
7607 while let Some(k) = map_.next_key()? {
7608 match k {
7609 GeneratedField::TaskId => {
7610 if task_id__.is_some() {
7611 return Err(serde::de::Error::duplicate_field("taskId"));
7612 }
7613 task_id__ = map_.next_value()?;
7614 }
7615 GeneratedField::OutputId => {
7616 if output_id__.is_some() {
7617 return Err(serde::de::Error::duplicate_field("outputId"));
7618 }
7619 output_id__ =
7620 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7621 ;
7622 }
7623 }
7624 }
7625 Ok(TaskOutputId {
7626 task_id: task_id__,
7627 output_id: output_id__.unwrap_or_default(),
7628 })
7629 }
7630 }
7631 deserializer.deserialize_struct("batch_plan.TaskOutputId", FIELDS, GeneratedVisitor)
7632 }
7633}
7634impl serde::Serialize for TopNNode {
7635 #[allow(deprecated)]
7636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7637 where
7638 S: serde::Serializer,
7639 {
7640 use serde::ser::SerializeStruct;
7641 let mut len = 0;
7642 if !self.column_orders.is_empty() {
7643 len += 1;
7644 }
7645 if self.limit != 0 {
7646 len += 1;
7647 }
7648 if self.offset != 0 {
7649 len += 1;
7650 }
7651 if self.with_ties {
7652 len += 1;
7653 }
7654 let mut struct_ser = serializer.serialize_struct("batch_plan.TopNNode", len)?;
7655 if !self.column_orders.is_empty() {
7656 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7657 }
7658 if self.limit != 0 {
7659 #[allow(clippy::needless_borrow)]
7660 #[allow(clippy::needless_borrows_for_generic_args)]
7661 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
7662 }
7663 if self.offset != 0 {
7664 #[allow(clippy::needless_borrow)]
7665 #[allow(clippy::needless_borrows_for_generic_args)]
7666 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
7667 }
7668 if self.with_ties {
7669 struct_ser.serialize_field("withTies", &self.with_ties)?;
7670 }
7671 struct_ser.end()
7672 }
7673}
7674impl<'de> serde::Deserialize<'de> for TopNNode {
7675 #[allow(deprecated)]
7676 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7677 where
7678 D: serde::Deserializer<'de>,
7679 {
7680 const FIELDS: &[&str] = &[
7681 "column_orders",
7682 "columnOrders",
7683 "limit",
7684 "offset",
7685 "with_ties",
7686 "withTies",
7687 ];
7688
7689 #[allow(clippy::enum_variant_names)]
7690 enum GeneratedField {
7691 ColumnOrders,
7692 Limit,
7693 Offset,
7694 WithTies,
7695 }
7696 impl<'de> serde::Deserialize<'de> for GeneratedField {
7697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7698 where
7699 D: serde::Deserializer<'de>,
7700 {
7701 struct GeneratedVisitor;
7702
7703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7704 type Value = GeneratedField;
7705
7706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7707 write!(formatter, "expected one of: {:?}", &FIELDS)
7708 }
7709
7710 #[allow(unused_variables)]
7711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7712 where
7713 E: serde::de::Error,
7714 {
7715 match value {
7716 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7717 "limit" => Ok(GeneratedField::Limit),
7718 "offset" => Ok(GeneratedField::Offset),
7719 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
7720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7721 }
7722 }
7723 }
7724 deserializer.deserialize_identifier(GeneratedVisitor)
7725 }
7726 }
7727 struct GeneratedVisitor;
7728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7729 type Value = TopNNode;
7730
7731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7732 formatter.write_str("struct batch_plan.TopNNode")
7733 }
7734
7735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
7736 where
7737 V: serde::de::MapAccess<'de>,
7738 {
7739 let mut column_orders__ = None;
7740 let mut limit__ = None;
7741 let mut offset__ = None;
7742 let mut with_ties__ = None;
7743 while let Some(k) = map_.next_key()? {
7744 match k {
7745 GeneratedField::ColumnOrders => {
7746 if column_orders__.is_some() {
7747 return Err(serde::de::Error::duplicate_field("columnOrders"));
7748 }
7749 column_orders__ = Some(map_.next_value()?);
7750 }
7751 GeneratedField::Limit => {
7752 if limit__.is_some() {
7753 return Err(serde::de::Error::duplicate_field("limit"));
7754 }
7755 limit__ =
7756 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7757 ;
7758 }
7759 GeneratedField::Offset => {
7760 if offset__.is_some() {
7761 return Err(serde::de::Error::duplicate_field("offset"));
7762 }
7763 offset__ =
7764 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7765 ;
7766 }
7767 GeneratedField::WithTies => {
7768 if with_ties__.is_some() {
7769 return Err(serde::de::Error::duplicate_field("withTies"));
7770 }
7771 with_ties__ = Some(map_.next_value()?);
7772 }
7773 }
7774 }
7775 Ok(TopNNode {
7776 column_orders: column_orders__.unwrap_or_default(),
7777 limit: limit__.unwrap_or_default(),
7778 offset: offset__.unwrap_or_default(),
7779 with_ties: with_ties__.unwrap_or_default(),
7780 })
7781 }
7782 }
7783 deserializer.deserialize_struct("batch_plan.TopNNode", FIELDS, GeneratedVisitor)
7784 }
7785}
7786impl serde::Serialize for UnionNode {
7787 #[allow(deprecated)]
7788 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7789 where
7790 S: serde::Serializer,
7791 {
7792 use serde::ser::SerializeStruct;
7793 let len = 0;
7794 let struct_ser = serializer.serialize_struct("batch_plan.UnionNode", len)?;
7795 struct_ser.end()
7796 }
7797}
7798impl<'de> serde::Deserialize<'de> for UnionNode {
7799 #[allow(deprecated)]
7800 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7801 where
7802 D: serde::Deserializer<'de>,
7803 {
7804 const FIELDS: &[&str] = &[
7805 ];
7806
7807 #[allow(clippy::enum_variant_names)]
7808 enum GeneratedField {
7809 }
7810 impl<'de> serde::Deserialize<'de> for GeneratedField {
7811 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7812 where
7813 D: serde::Deserializer<'de>,
7814 {
7815 struct GeneratedVisitor;
7816
7817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7818 type Value = GeneratedField;
7819
7820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7821 write!(formatter, "expected one of: {:?}", &FIELDS)
7822 }
7823
7824 #[allow(unused_variables)]
7825 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7826 where
7827 E: serde::de::Error,
7828 {
7829 Err(serde::de::Error::unknown_field(value, FIELDS))
7830 }
7831 }
7832 deserializer.deserialize_identifier(GeneratedVisitor)
7833 }
7834 }
7835 struct GeneratedVisitor;
7836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7837 type Value = UnionNode;
7838
7839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7840 formatter.write_str("struct batch_plan.UnionNode")
7841 }
7842
7843 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
7844 where
7845 V: serde::de::MapAccess<'de>,
7846 {
7847 while map_.next_key::<GeneratedField>()?.is_some() {
7848 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7849 }
7850 Ok(UnionNode {
7851 })
7852 }
7853 }
7854 deserializer.deserialize_struct("batch_plan.UnionNode", FIELDS, GeneratedVisitor)
7855 }
7856}
7857impl serde::Serialize for UpdateNode {
7858 #[allow(deprecated)]
7859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7860 where
7861 S: serde::Serializer,
7862 {
7863 use serde::ser::SerializeStruct;
7864 let mut len = 0;
7865 if self.table_id != 0 {
7866 len += 1;
7867 }
7868 if self.table_version_id != 0 {
7869 len += 1;
7870 }
7871 if !self.old_exprs.is_empty() {
7872 len += 1;
7873 }
7874 if !self.new_exprs.is_empty() {
7875 len += 1;
7876 }
7877 if self.returning {
7878 len += 1;
7879 }
7880 if self.session_id != 0 {
7881 len += 1;
7882 }
7883 let mut struct_ser = serializer.serialize_struct("batch_plan.UpdateNode", len)?;
7884 if self.table_id != 0 {
7885 struct_ser.serialize_field("tableId", &self.table_id)?;
7886 }
7887 if self.table_version_id != 0 {
7888 #[allow(clippy::needless_borrow)]
7889 #[allow(clippy::needless_borrows_for_generic_args)]
7890 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
7891 }
7892 if !self.old_exprs.is_empty() {
7893 struct_ser.serialize_field("oldExprs", &self.old_exprs)?;
7894 }
7895 if !self.new_exprs.is_empty() {
7896 struct_ser.serialize_field("newExprs", &self.new_exprs)?;
7897 }
7898 if self.returning {
7899 struct_ser.serialize_field("returning", &self.returning)?;
7900 }
7901 if self.session_id != 0 {
7902 struct_ser.serialize_field("sessionId", &self.session_id)?;
7903 }
7904 struct_ser.end()
7905 }
7906}
7907impl<'de> serde::Deserialize<'de> for UpdateNode {
7908 #[allow(deprecated)]
7909 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7910 where
7911 D: serde::Deserializer<'de>,
7912 {
7913 const FIELDS: &[&str] = &[
7914 "table_id",
7915 "tableId",
7916 "table_version_id",
7917 "tableVersionId",
7918 "old_exprs",
7919 "oldExprs",
7920 "new_exprs",
7921 "newExprs",
7922 "returning",
7923 "session_id",
7924 "sessionId",
7925 ];
7926
7927 #[allow(clippy::enum_variant_names)]
7928 enum GeneratedField {
7929 TableId,
7930 TableVersionId,
7931 OldExprs,
7932 NewExprs,
7933 Returning,
7934 SessionId,
7935 }
7936 impl<'de> serde::Deserialize<'de> for GeneratedField {
7937 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7938 where
7939 D: serde::Deserializer<'de>,
7940 {
7941 struct GeneratedVisitor;
7942
7943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7944 type Value = GeneratedField;
7945
7946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7947 write!(formatter, "expected one of: {:?}", &FIELDS)
7948 }
7949
7950 #[allow(unused_variables)]
7951 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7952 where
7953 E: serde::de::Error,
7954 {
7955 match value {
7956 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7957 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
7958 "oldExprs" | "old_exprs" => Ok(GeneratedField::OldExprs),
7959 "newExprs" | "new_exprs" => Ok(GeneratedField::NewExprs),
7960 "returning" => Ok(GeneratedField::Returning),
7961 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
7962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7963 }
7964 }
7965 }
7966 deserializer.deserialize_identifier(GeneratedVisitor)
7967 }
7968 }
7969 struct GeneratedVisitor;
7970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7971 type Value = UpdateNode;
7972
7973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7974 formatter.write_str("struct batch_plan.UpdateNode")
7975 }
7976
7977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateNode, V::Error>
7978 where
7979 V: serde::de::MapAccess<'de>,
7980 {
7981 let mut table_id__ = None;
7982 let mut table_version_id__ = None;
7983 let mut old_exprs__ = None;
7984 let mut new_exprs__ = None;
7985 let mut returning__ = None;
7986 let mut session_id__ = None;
7987 while let Some(k) = map_.next_key()? {
7988 match k {
7989 GeneratedField::TableId => {
7990 if table_id__.is_some() {
7991 return Err(serde::de::Error::duplicate_field("tableId"));
7992 }
7993 table_id__ =
7994 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7995 ;
7996 }
7997 GeneratedField::TableVersionId => {
7998 if table_version_id__.is_some() {
7999 return Err(serde::de::Error::duplicate_field("tableVersionId"));
8000 }
8001 table_version_id__ =
8002 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8003 ;
8004 }
8005 GeneratedField::OldExprs => {
8006 if old_exprs__.is_some() {
8007 return Err(serde::de::Error::duplicate_field("oldExprs"));
8008 }
8009 old_exprs__ = Some(map_.next_value()?);
8010 }
8011 GeneratedField::NewExprs => {
8012 if new_exprs__.is_some() {
8013 return Err(serde::de::Error::duplicate_field("newExprs"));
8014 }
8015 new_exprs__ = Some(map_.next_value()?);
8016 }
8017 GeneratedField::Returning => {
8018 if returning__.is_some() {
8019 return Err(serde::de::Error::duplicate_field("returning"));
8020 }
8021 returning__ = Some(map_.next_value()?);
8022 }
8023 GeneratedField::SessionId => {
8024 if session_id__.is_some() {
8025 return Err(serde::de::Error::duplicate_field("sessionId"));
8026 }
8027 session_id__ =
8028 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8029 ;
8030 }
8031 }
8032 }
8033 Ok(UpdateNode {
8034 table_id: table_id__.unwrap_or_default(),
8035 table_version_id: table_version_id__.unwrap_or_default(),
8036 old_exprs: old_exprs__.unwrap_or_default(),
8037 new_exprs: new_exprs__.unwrap_or_default(),
8038 returning: returning__.unwrap_or_default(),
8039 session_id: session_id__.unwrap_or_default(),
8040 })
8041 }
8042 }
8043 deserializer.deserialize_struct("batch_plan.UpdateNode", FIELDS, GeneratedVisitor)
8044 }
8045}
8046impl serde::Serialize for ValuesNode {
8047 #[allow(deprecated)]
8048 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8049 where
8050 S: serde::Serializer,
8051 {
8052 use serde::ser::SerializeStruct;
8053 let mut len = 0;
8054 if !self.tuples.is_empty() {
8055 len += 1;
8056 }
8057 if !self.fields.is_empty() {
8058 len += 1;
8059 }
8060 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode", len)?;
8061 if !self.tuples.is_empty() {
8062 struct_ser.serialize_field("tuples", &self.tuples)?;
8063 }
8064 if !self.fields.is_empty() {
8065 struct_ser.serialize_field("fields", &self.fields)?;
8066 }
8067 struct_ser.end()
8068 }
8069}
8070impl<'de> serde::Deserialize<'de> for ValuesNode {
8071 #[allow(deprecated)]
8072 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8073 where
8074 D: serde::Deserializer<'de>,
8075 {
8076 const FIELDS: &[&str] = &[
8077 "tuples",
8078 "fields",
8079 ];
8080
8081 #[allow(clippy::enum_variant_names)]
8082 enum GeneratedField {
8083 Tuples,
8084 Fields,
8085 }
8086 impl<'de> serde::Deserialize<'de> for GeneratedField {
8087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8088 where
8089 D: serde::Deserializer<'de>,
8090 {
8091 struct GeneratedVisitor;
8092
8093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8094 type Value = GeneratedField;
8095
8096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8097 write!(formatter, "expected one of: {:?}", &FIELDS)
8098 }
8099
8100 #[allow(unused_variables)]
8101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8102 where
8103 E: serde::de::Error,
8104 {
8105 match value {
8106 "tuples" => Ok(GeneratedField::Tuples),
8107 "fields" => Ok(GeneratedField::Fields),
8108 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8109 }
8110 }
8111 }
8112 deserializer.deserialize_identifier(GeneratedVisitor)
8113 }
8114 }
8115 struct GeneratedVisitor;
8116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8117 type Value = ValuesNode;
8118
8119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8120 formatter.write_str("struct batch_plan.ValuesNode")
8121 }
8122
8123 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
8124 where
8125 V: serde::de::MapAccess<'de>,
8126 {
8127 let mut tuples__ = None;
8128 let mut fields__ = None;
8129 while let Some(k) = map_.next_key()? {
8130 match k {
8131 GeneratedField::Tuples => {
8132 if tuples__.is_some() {
8133 return Err(serde::de::Error::duplicate_field("tuples"));
8134 }
8135 tuples__ = Some(map_.next_value()?);
8136 }
8137 GeneratedField::Fields => {
8138 if fields__.is_some() {
8139 return Err(serde::de::Error::duplicate_field("fields"));
8140 }
8141 fields__ = Some(map_.next_value()?);
8142 }
8143 }
8144 }
8145 Ok(ValuesNode {
8146 tuples: tuples__.unwrap_or_default(),
8147 fields: fields__.unwrap_or_default(),
8148 })
8149 }
8150 }
8151 deserializer.deserialize_struct("batch_plan.ValuesNode", FIELDS, GeneratedVisitor)
8152 }
8153}
8154impl serde::Serialize for values_node::ExprTuple {
8155 #[allow(deprecated)]
8156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8157 where
8158 S: serde::Serializer,
8159 {
8160 use serde::ser::SerializeStruct;
8161 let mut len = 0;
8162 if !self.cells.is_empty() {
8163 len += 1;
8164 }
8165 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode.ExprTuple", len)?;
8166 if !self.cells.is_empty() {
8167 struct_ser.serialize_field("cells", &self.cells)?;
8168 }
8169 struct_ser.end()
8170 }
8171}
8172impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
8173 #[allow(deprecated)]
8174 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8175 where
8176 D: serde::Deserializer<'de>,
8177 {
8178 const FIELDS: &[&str] = &[
8179 "cells",
8180 ];
8181
8182 #[allow(clippy::enum_variant_names)]
8183 enum GeneratedField {
8184 Cells,
8185 }
8186 impl<'de> serde::Deserialize<'de> for GeneratedField {
8187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8188 where
8189 D: serde::Deserializer<'de>,
8190 {
8191 struct GeneratedVisitor;
8192
8193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8194 type Value = GeneratedField;
8195
8196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8197 write!(formatter, "expected one of: {:?}", &FIELDS)
8198 }
8199
8200 #[allow(unused_variables)]
8201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8202 where
8203 E: serde::de::Error,
8204 {
8205 match value {
8206 "cells" => Ok(GeneratedField::Cells),
8207 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8208 }
8209 }
8210 }
8211 deserializer.deserialize_identifier(GeneratedVisitor)
8212 }
8213 }
8214 struct GeneratedVisitor;
8215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8216 type Value = values_node::ExprTuple;
8217
8218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8219 formatter.write_str("struct batch_plan.ValuesNode.ExprTuple")
8220 }
8221
8222 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
8223 where
8224 V: serde::de::MapAccess<'de>,
8225 {
8226 let mut cells__ = None;
8227 while let Some(k) = map_.next_key()? {
8228 match k {
8229 GeneratedField::Cells => {
8230 if cells__.is_some() {
8231 return Err(serde::de::Error::duplicate_field("cells"));
8232 }
8233 cells__ = Some(map_.next_value()?);
8234 }
8235 }
8236 }
8237 Ok(values_node::ExprTuple {
8238 cells: cells__.unwrap_or_default(),
8239 })
8240 }
8241 }
8242 deserializer.deserialize_struct("batch_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
8243 }
8244}
8245impl serde::Serialize for VectorIndexNearestNode {
8246 #[allow(deprecated)]
8247 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8248 where
8249 S: serde::Serializer,
8250 {
8251 use serde::ser::SerializeStruct;
8252 let mut len = 0;
8253 if self.table_id != 0 {
8254 len += 1;
8255 }
8256 if !self.info_column_desc.is_empty() {
8257 len += 1;
8258 }
8259 if self.vector_column_idx != 0 {
8260 len += 1;
8261 }
8262 if self.top_n != 0 {
8263 len += 1;
8264 }
8265 if self.distance_type != 0 {
8266 len += 1;
8267 }
8268 if self.hnsw_ef_search != 0 {
8269 len += 1;
8270 }
8271 let mut struct_ser = serializer.serialize_struct("batch_plan.VectorIndexNearestNode", len)?;
8272 if self.table_id != 0 {
8273 struct_ser.serialize_field("tableId", &self.table_id)?;
8274 }
8275 if !self.info_column_desc.is_empty() {
8276 struct_ser.serialize_field("infoColumnDesc", &self.info_column_desc)?;
8277 }
8278 if self.vector_column_idx != 0 {
8279 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
8280 }
8281 if self.top_n != 0 {
8282 struct_ser.serialize_field("topN", &self.top_n)?;
8283 }
8284 if self.distance_type != 0 {
8285 let v = super::common::DistanceType::try_from(self.distance_type)
8286 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
8287 struct_ser.serialize_field("distanceType", &v)?;
8288 }
8289 if self.hnsw_ef_search != 0 {
8290 struct_ser.serialize_field("hnswEfSearch", &self.hnsw_ef_search)?;
8291 }
8292 struct_ser.end()
8293 }
8294}
8295impl<'de> serde::Deserialize<'de> for VectorIndexNearestNode {
8296 #[allow(deprecated)]
8297 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8298 where
8299 D: serde::Deserializer<'de>,
8300 {
8301 const FIELDS: &[&str] = &[
8302 "table_id",
8303 "tableId",
8304 "info_column_desc",
8305 "infoColumnDesc",
8306 "vector_column_idx",
8307 "vectorColumnIdx",
8308 "top_n",
8309 "topN",
8310 "distance_type",
8311 "distanceType",
8312 "hnsw_ef_search",
8313 "hnswEfSearch",
8314 ];
8315
8316 #[allow(clippy::enum_variant_names)]
8317 enum GeneratedField {
8318 TableId,
8319 InfoColumnDesc,
8320 VectorColumnIdx,
8321 TopN,
8322 DistanceType,
8323 HnswEfSearch,
8324 }
8325 impl<'de> serde::Deserialize<'de> for GeneratedField {
8326 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8327 where
8328 D: serde::Deserializer<'de>,
8329 {
8330 struct GeneratedVisitor;
8331
8332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8333 type Value = GeneratedField;
8334
8335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8336 write!(formatter, "expected one of: {:?}", &FIELDS)
8337 }
8338
8339 #[allow(unused_variables)]
8340 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8341 where
8342 E: serde::de::Error,
8343 {
8344 match value {
8345 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8346 "infoColumnDesc" | "info_column_desc" => Ok(GeneratedField::InfoColumnDesc),
8347 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
8348 "topN" | "top_n" => Ok(GeneratedField::TopN),
8349 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
8350 "hnswEfSearch" | "hnsw_ef_search" => Ok(GeneratedField::HnswEfSearch),
8351 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8352 }
8353 }
8354 }
8355 deserializer.deserialize_identifier(GeneratedVisitor)
8356 }
8357 }
8358 struct GeneratedVisitor;
8359 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8360 type Value = VectorIndexNearestNode;
8361
8362 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8363 formatter.write_str("struct batch_plan.VectorIndexNearestNode")
8364 }
8365
8366 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexNearestNode, V::Error>
8367 where
8368 V: serde::de::MapAccess<'de>,
8369 {
8370 let mut table_id__ = None;
8371 let mut info_column_desc__ = None;
8372 let mut vector_column_idx__ = None;
8373 let mut top_n__ = None;
8374 let mut distance_type__ = None;
8375 let mut hnsw_ef_search__ = None;
8376 while let Some(k) = map_.next_key()? {
8377 match k {
8378 GeneratedField::TableId => {
8379 if table_id__.is_some() {
8380 return Err(serde::de::Error::duplicate_field("tableId"));
8381 }
8382 table_id__ =
8383 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8384 ;
8385 }
8386 GeneratedField::InfoColumnDesc => {
8387 if info_column_desc__.is_some() {
8388 return Err(serde::de::Error::duplicate_field("infoColumnDesc"));
8389 }
8390 info_column_desc__ = Some(map_.next_value()?);
8391 }
8392 GeneratedField::VectorColumnIdx => {
8393 if vector_column_idx__.is_some() {
8394 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
8395 }
8396 vector_column_idx__ =
8397 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8398 ;
8399 }
8400 GeneratedField::TopN => {
8401 if top_n__.is_some() {
8402 return Err(serde::de::Error::duplicate_field("topN"));
8403 }
8404 top_n__ =
8405 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8406 ;
8407 }
8408 GeneratedField::DistanceType => {
8409 if distance_type__.is_some() {
8410 return Err(serde::de::Error::duplicate_field("distanceType"));
8411 }
8412 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
8413 }
8414 GeneratedField::HnswEfSearch => {
8415 if hnsw_ef_search__.is_some() {
8416 return Err(serde::de::Error::duplicate_field("hnswEfSearch"));
8417 }
8418 hnsw_ef_search__ =
8419 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8420 ;
8421 }
8422 }
8423 }
8424 Ok(VectorIndexNearestNode {
8425 table_id: table_id__.unwrap_or_default(),
8426 info_column_desc: info_column_desc__.unwrap_or_default(),
8427 vector_column_idx: vector_column_idx__.unwrap_or_default(),
8428 top_n: top_n__.unwrap_or_default(),
8429 distance_type: distance_type__.unwrap_or_default(),
8430 hnsw_ef_search: hnsw_ef_search__.unwrap_or_default(),
8431 })
8432 }
8433 }
8434 deserializer.deserialize_struct("batch_plan.VectorIndexNearestNode", FIELDS, GeneratedVisitor)
8435 }
8436}