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.query_epoch.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.query_epoch.as_ref() {
480 struct_ser.serialize_field("queryEpoch", 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 "query_epoch",
513 "queryEpoch",
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 QueryEpoch,
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 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
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 query_epoch__ = 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::QueryEpoch => {
664 if query_epoch__.is_some() {
665 return Err(serde::de::Error::duplicate_field("queryEpoch"));
666 }
667 query_epoch__ = 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 query_epoch: query_epoch__,
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.tracing_context.is_empty() {
3754 len += 1;
3755 }
3756 let mut struct_ser = serializer.serialize_struct("batch_plan.LocalExecutePlan", len)?;
3757 if let Some(v) = self.plan.as_ref() {
3758 struct_ser.serialize_field("plan", v)?;
3759 }
3760 if !self.tracing_context.is_empty() {
3761 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
3762 }
3763 struct_ser.end()
3764 }
3765}
3766impl<'de> serde::Deserialize<'de> for LocalExecutePlan {
3767 #[allow(deprecated)]
3768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3769 where
3770 D: serde::Deserializer<'de>,
3771 {
3772 const FIELDS: &[&str] = &[
3773 "plan",
3774 "tracing_context",
3775 "tracingContext",
3776 ];
3777
3778 #[allow(clippy::enum_variant_names)]
3779 enum GeneratedField {
3780 Plan,
3781 TracingContext,
3782 }
3783 impl<'de> serde::Deserialize<'de> for GeneratedField {
3784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3785 where
3786 D: serde::Deserializer<'de>,
3787 {
3788 struct GeneratedVisitor;
3789
3790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3791 type Value = GeneratedField;
3792
3793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3794 write!(formatter, "expected one of: {:?}", &FIELDS)
3795 }
3796
3797 #[allow(unused_variables)]
3798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3799 where
3800 E: serde::de::Error,
3801 {
3802 match value {
3803 "plan" => Ok(GeneratedField::Plan),
3804 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
3805 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3806 }
3807 }
3808 }
3809 deserializer.deserialize_identifier(GeneratedVisitor)
3810 }
3811 }
3812 struct GeneratedVisitor;
3813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3814 type Value = LocalExecutePlan;
3815
3816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3817 formatter.write_str("struct batch_plan.LocalExecutePlan")
3818 }
3819
3820 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalExecutePlan, V::Error>
3821 where
3822 V: serde::de::MapAccess<'de>,
3823 {
3824 let mut plan__ = None;
3825 let mut tracing_context__ = None;
3826 while let Some(k) = map_.next_key()? {
3827 match k {
3828 GeneratedField::Plan => {
3829 if plan__.is_some() {
3830 return Err(serde::de::Error::duplicate_field("plan"));
3831 }
3832 plan__ = map_.next_value()?;
3833 }
3834 GeneratedField::TracingContext => {
3835 if tracing_context__.is_some() {
3836 return Err(serde::de::Error::duplicate_field("tracingContext"));
3837 }
3838 tracing_context__ = Some(
3839 map_.next_value::<std::collections::HashMap<_, _>>()?
3840 );
3841 }
3842 }
3843 }
3844 Ok(LocalExecutePlan {
3845 plan: plan__,
3846 tracing_context: tracing_context__.unwrap_or_default(),
3847 })
3848 }
3849 }
3850 deserializer.deserialize_struct("batch_plan.LocalExecutePlan", FIELDS, GeneratedVisitor)
3851 }
3852}
3853impl serde::Serialize for LocalLookupJoinNode {
3854 #[allow(deprecated)]
3855 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3856 where
3857 S: serde::Serializer,
3858 {
3859 use serde::ser::SerializeStruct;
3860 let mut len = 0;
3861 if self.join_type != 0 {
3862 len += 1;
3863 }
3864 if self.condition.is_some() {
3865 len += 1;
3866 }
3867 if !self.outer_side_key.is_empty() {
3868 len += 1;
3869 }
3870 if !self.inner_side_key.is_empty() {
3871 len += 1;
3872 }
3873 if self.lookup_prefix_len != 0 {
3874 len += 1;
3875 }
3876 if self.inner_side_table_desc.is_some() {
3877 len += 1;
3878 }
3879 if !self.inner_side_vnode_mapping.is_empty() {
3880 len += 1;
3881 }
3882 if !self.inner_side_column_ids.is_empty() {
3883 len += 1;
3884 }
3885 if !self.output_indices.is_empty() {
3886 len += 1;
3887 }
3888 if !self.worker_nodes.is_empty() {
3889 len += 1;
3890 }
3891 if !self.null_safe.is_empty() {
3892 len += 1;
3893 }
3894 if self.query_epoch.is_some() {
3895 len += 1;
3896 }
3897 if self.asof_desc.is_some() {
3898 len += 1;
3899 }
3900 let mut struct_ser = serializer.serialize_struct("batch_plan.LocalLookupJoinNode", len)?;
3901 if self.join_type != 0 {
3902 let v = super::plan_common::JoinType::try_from(self.join_type)
3903 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3904 struct_ser.serialize_field("joinType", &v)?;
3905 }
3906 if let Some(v) = self.condition.as_ref() {
3907 struct_ser.serialize_field("condition", v)?;
3908 }
3909 if !self.outer_side_key.is_empty() {
3910 struct_ser.serialize_field("outerSideKey", &self.outer_side_key)?;
3911 }
3912 if !self.inner_side_key.is_empty() {
3913 struct_ser.serialize_field("innerSideKey", &self.inner_side_key)?;
3914 }
3915 if self.lookup_prefix_len != 0 {
3916 struct_ser.serialize_field("lookupPrefixLen", &self.lookup_prefix_len)?;
3917 }
3918 if let Some(v) = self.inner_side_table_desc.as_ref() {
3919 struct_ser.serialize_field("innerSideTableDesc", v)?;
3920 }
3921 if !self.inner_side_vnode_mapping.is_empty() {
3922 struct_ser.serialize_field("innerSideVnodeMapping", &self.inner_side_vnode_mapping.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3923 }
3924 if !self.inner_side_column_ids.is_empty() {
3925 struct_ser.serialize_field("innerSideColumnIds", &self.inner_side_column_ids)?;
3926 }
3927 if !self.output_indices.is_empty() {
3928 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3929 }
3930 if !self.worker_nodes.is_empty() {
3931 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
3932 }
3933 if !self.null_safe.is_empty() {
3934 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
3935 }
3936 if let Some(v) = self.query_epoch.as_ref() {
3937 struct_ser.serialize_field("queryEpoch", v)?;
3938 }
3939 if let Some(v) = self.asof_desc.as_ref() {
3940 struct_ser.serialize_field("asofDesc", v)?;
3941 }
3942 struct_ser.end()
3943 }
3944}
3945impl<'de> serde::Deserialize<'de> for LocalLookupJoinNode {
3946 #[allow(deprecated)]
3947 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3948 where
3949 D: serde::Deserializer<'de>,
3950 {
3951 const FIELDS: &[&str] = &[
3952 "join_type",
3953 "joinType",
3954 "condition",
3955 "outer_side_key",
3956 "outerSideKey",
3957 "inner_side_key",
3958 "innerSideKey",
3959 "lookup_prefix_len",
3960 "lookupPrefixLen",
3961 "inner_side_table_desc",
3962 "innerSideTableDesc",
3963 "inner_side_vnode_mapping",
3964 "innerSideVnodeMapping",
3965 "inner_side_column_ids",
3966 "innerSideColumnIds",
3967 "output_indices",
3968 "outputIndices",
3969 "worker_nodes",
3970 "workerNodes",
3971 "null_safe",
3972 "nullSafe",
3973 "query_epoch",
3974 "queryEpoch",
3975 "asof_desc",
3976 "asofDesc",
3977 ];
3978
3979 #[allow(clippy::enum_variant_names)]
3980 enum GeneratedField {
3981 JoinType,
3982 Condition,
3983 OuterSideKey,
3984 InnerSideKey,
3985 LookupPrefixLen,
3986 InnerSideTableDesc,
3987 InnerSideVnodeMapping,
3988 InnerSideColumnIds,
3989 OutputIndices,
3990 WorkerNodes,
3991 NullSafe,
3992 QueryEpoch,
3993 AsofDesc,
3994 }
3995 impl<'de> serde::Deserialize<'de> for GeneratedField {
3996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3997 where
3998 D: serde::Deserializer<'de>,
3999 {
4000 struct GeneratedVisitor;
4001
4002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4003 type Value = GeneratedField;
4004
4005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4006 write!(formatter, "expected one of: {:?}", &FIELDS)
4007 }
4008
4009 #[allow(unused_variables)]
4010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4011 where
4012 E: serde::de::Error,
4013 {
4014 match value {
4015 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
4016 "condition" => Ok(GeneratedField::Condition),
4017 "outerSideKey" | "outer_side_key" => Ok(GeneratedField::OuterSideKey),
4018 "innerSideKey" | "inner_side_key" => Ok(GeneratedField::InnerSideKey),
4019 "lookupPrefixLen" | "lookup_prefix_len" => Ok(GeneratedField::LookupPrefixLen),
4020 "innerSideTableDesc" | "inner_side_table_desc" => Ok(GeneratedField::InnerSideTableDesc),
4021 "innerSideVnodeMapping" | "inner_side_vnode_mapping" => Ok(GeneratedField::InnerSideVnodeMapping),
4022 "innerSideColumnIds" | "inner_side_column_ids" => Ok(GeneratedField::InnerSideColumnIds),
4023 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
4024 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
4025 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
4026 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
4027 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
4028 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4029 }
4030 }
4031 }
4032 deserializer.deserialize_identifier(GeneratedVisitor)
4033 }
4034 }
4035 struct GeneratedVisitor;
4036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4037 type Value = LocalLookupJoinNode;
4038
4039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4040 formatter.write_str("struct batch_plan.LocalLookupJoinNode")
4041 }
4042
4043 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalLookupJoinNode, V::Error>
4044 where
4045 V: serde::de::MapAccess<'de>,
4046 {
4047 let mut join_type__ = None;
4048 let mut condition__ = None;
4049 let mut outer_side_key__ = None;
4050 let mut inner_side_key__ = None;
4051 let mut lookup_prefix_len__ = None;
4052 let mut inner_side_table_desc__ = None;
4053 let mut inner_side_vnode_mapping__ = None;
4054 let mut inner_side_column_ids__ = None;
4055 let mut output_indices__ = None;
4056 let mut worker_nodes__ = None;
4057 let mut null_safe__ = None;
4058 let mut query_epoch__ = None;
4059 let mut asof_desc__ = None;
4060 while let Some(k) = map_.next_key()? {
4061 match k {
4062 GeneratedField::JoinType => {
4063 if join_type__.is_some() {
4064 return Err(serde::de::Error::duplicate_field("joinType"));
4065 }
4066 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
4067 }
4068 GeneratedField::Condition => {
4069 if condition__.is_some() {
4070 return Err(serde::de::Error::duplicate_field("condition"));
4071 }
4072 condition__ = map_.next_value()?;
4073 }
4074 GeneratedField::OuterSideKey => {
4075 if outer_side_key__.is_some() {
4076 return Err(serde::de::Error::duplicate_field("outerSideKey"));
4077 }
4078 outer_side_key__ =
4079 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4080 .into_iter().map(|x| x.0).collect())
4081 ;
4082 }
4083 GeneratedField::InnerSideKey => {
4084 if inner_side_key__.is_some() {
4085 return Err(serde::de::Error::duplicate_field("innerSideKey"));
4086 }
4087 inner_side_key__ =
4088 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4089 .into_iter().map(|x| x.0).collect())
4090 ;
4091 }
4092 GeneratedField::LookupPrefixLen => {
4093 if lookup_prefix_len__.is_some() {
4094 return Err(serde::de::Error::duplicate_field("lookupPrefixLen"));
4095 }
4096 lookup_prefix_len__ =
4097 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4098 ;
4099 }
4100 GeneratedField::InnerSideTableDesc => {
4101 if inner_side_table_desc__.is_some() {
4102 return Err(serde::de::Error::duplicate_field("innerSideTableDesc"));
4103 }
4104 inner_side_table_desc__ = map_.next_value()?;
4105 }
4106 GeneratedField::InnerSideVnodeMapping => {
4107 if inner_side_vnode_mapping__.is_some() {
4108 return Err(serde::de::Error::duplicate_field("innerSideVnodeMapping"));
4109 }
4110 inner_side_vnode_mapping__ =
4111 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4112 .into_iter().map(|x| x.0).collect())
4113 ;
4114 }
4115 GeneratedField::InnerSideColumnIds => {
4116 if inner_side_column_ids__.is_some() {
4117 return Err(serde::de::Error::duplicate_field("innerSideColumnIds"));
4118 }
4119 inner_side_column_ids__ =
4120 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4121 .into_iter().map(|x| x.0).collect())
4122 ;
4123 }
4124 GeneratedField::OutputIndices => {
4125 if output_indices__.is_some() {
4126 return Err(serde::de::Error::duplicate_field("outputIndices"));
4127 }
4128 output_indices__ =
4129 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4130 .into_iter().map(|x| x.0).collect())
4131 ;
4132 }
4133 GeneratedField::WorkerNodes => {
4134 if worker_nodes__.is_some() {
4135 return Err(serde::de::Error::duplicate_field("workerNodes"));
4136 }
4137 worker_nodes__ = Some(map_.next_value()?);
4138 }
4139 GeneratedField::NullSafe => {
4140 if null_safe__.is_some() {
4141 return Err(serde::de::Error::duplicate_field("nullSafe"));
4142 }
4143 null_safe__ = Some(map_.next_value()?);
4144 }
4145 GeneratedField::QueryEpoch => {
4146 if query_epoch__.is_some() {
4147 return Err(serde::de::Error::duplicate_field("queryEpoch"));
4148 }
4149 query_epoch__ = map_.next_value()?;
4150 }
4151 GeneratedField::AsofDesc => {
4152 if asof_desc__.is_some() {
4153 return Err(serde::de::Error::duplicate_field("asofDesc"));
4154 }
4155 asof_desc__ = map_.next_value()?;
4156 }
4157 }
4158 }
4159 Ok(LocalLookupJoinNode {
4160 join_type: join_type__.unwrap_or_default(),
4161 condition: condition__,
4162 outer_side_key: outer_side_key__.unwrap_or_default(),
4163 inner_side_key: inner_side_key__.unwrap_or_default(),
4164 lookup_prefix_len: lookup_prefix_len__.unwrap_or_default(),
4165 inner_side_table_desc: inner_side_table_desc__,
4166 inner_side_vnode_mapping: inner_side_vnode_mapping__.unwrap_or_default(),
4167 inner_side_column_ids: inner_side_column_ids__.unwrap_or_default(),
4168 output_indices: output_indices__.unwrap_or_default(),
4169 worker_nodes: worker_nodes__.unwrap_or_default(),
4170 null_safe: null_safe__.unwrap_or_default(),
4171 query_epoch: query_epoch__,
4172 asof_desc: asof_desc__,
4173 })
4174 }
4175 }
4176 deserializer.deserialize_struct("batch_plan.LocalLookupJoinNode", FIELDS, GeneratedVisitor)
4177 }
4178}
4179impl serde::Serialize for LogRowSeqScanNode {
4180 #[allow(deprecated)]
4181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4182 where
4183 S: serde::Serializer,
4184 {
4185 use serde::ser::SerializeStruct;
4186 let mut len = 0;
4187 if self.table_desc.is_some() {
4188 len += 1;
4189 }
4190 if !self.column_ids.is_empty() {
4191 len += 1;
4192 }
4193 if self.vnode_bitmap.is_some() {
4194 len += 1;
4195 }
4196 if self.old_epoch.is_some() {
4197 len += 1;
4198 }
4199 if self.new_epoch.is_some() {
4200 len += 1;
4201 }
4202 if self.ordered {
4203 len += 1;
4204 }
4205 if self.scan_range.is_some() {
4206 len += 1;
4207 }
4208 let mut struct_ser = serializer.serialize_struct("batch_plan.LogRowSeqScanNode", len)?;
4209 if let Some(v) = self.table_desc.as_ref() {
4210 struct_ser.serialize_field("tableDesc", v)?;
4211 }
4212 if !self.column_ids.is_empty() {
4213 struct_ser.serialize_field("columnIds", &self.column_ids)?;
4214 }
4215 if let Some(v) = self.vnode_bitmap.as_ref() {
4216 struct_ser.serialize_field("vnodeBitmap", v)?;
4217 }
4218 if let Some(v) = self.old_epoch.as_ref() {
4219 struct_ser.serialize_field("oldEpoch", v)?;
4220 }
4221 if let Some(v) = self.new_epoch.as_ref() {
4222 struct_ser.serialize_field("newEpoch", v)?;
4223 }
4224 if self.ordered {
4225 struct_ser.serialize_field("ordered", &self.ordered)?;
4226 }
4227 if let Some(v) = self.scan_range.as_ref() {
4228 struct_ser.serialize_field("scanRange", v)?;
4229 }
4230 struct_ser.end()
4231 }
4232}
4233impl<'de> serde::Deserialize<'de> for LogRowSeqScanNode {
4234 #[allow(deprecated)]
4235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4236 where
4237 D: serde::Deserializer<'de>,
4238 {
4239 const FIELDS: &[&str] = &[
4240 "table_desc",
4241 "tableDesc",
4242 "column_ids",
4243 "columnIds",
4244 "vnode_bitmap",
4245 "vnodeBitmap",
4246 "old_epoch",
4247 "oldEpoch",
4248 "new_epoch",
4249 "newEpoch",
4250 "ordered",
4251 "scan_range",
4252 "scanRange",
4253 ];
4254
4255 #[allow(clippy::enum_variant_names)]
4256 enum GeneratedField {
4257 TableDesc,
4258 ColumnIds,
4259 VnodeBitmap,
4260 OldEpoch,
4261 NewEpoch,
4262 Ordered,
4263 ScanRange,
4264 }
4265 impl<'de> serde::Deserialize<'de> for GeneratedField {
4266 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4267 where
4268 D: serde::Deserializer<'de>,
4269 {
4270 struct GeneratedVisitor;
4271
4272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4273 type Value = GeneratedField;
4274
4275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4276 write!(formatter, "expected one of: {:?}", &FIELDS)
4277 }
4278
4279 #[allow(unused_variables)]
4280 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4281 where
4282 E: serde::de::Error,
4283 {
4284 match value {
4285 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
4286 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
4287 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
4288 "oldEpoch" | "old_epoch" => Ok(GeneratedField::OldEpoch),
4289 "newEpoch" | "new_epoch" => Ok(GeneratedField::NewEpoch),
4290 "ordered" => Ok(GeneratedField::Ordered),
4291 "scanRange" | "scan_range" => Ok(GeneratedField::ScanRange),
4292 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4293 }
4294 }
4295 }
4296 deserializer.deserialize_identifier(GeneratedVisitor)
4297 }
4298 }
4299 struct GeneratedVisitor;
4300 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4301 type Value = LogRowSeqScanNode;
4302
4303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4304 formatter.write_str("struct batch_plan.LogRowSeqScanNode")
4305 }
4306
4307 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LogRowSeqScanNode, V::Error>
4308 where
4309 V: serde::de::MapAccess<'de>,
4310 {
4311 let mut table_desc__ = None;
4312 let mut column_ids__ = None;
4313 let mut vnode_bitmap__ = None;
4314 let mut old_epoch__ = None;
4315 let mut new_epoch__ = None;
4316 let mut ordered__ = None;
4317 let mut scan_range__ = None;
4318 while let Some(k) = map_.next_key()? {
4319 match k {
4320 GeneratedField::TableDesc => {
4321 if table_desc__.is_some() {
4322 return Err(serde::de::Error::duplicate_field("tableDesc"));
4323 }
4324 table_desc__ = map_.next_value()?;
4325 }
4326 GeneratedField::ColumnIds => {
4327 if column_ids__.is_some() {
4328 return Err(serde::de::Error::duplicate_field("columnIds"));
4329 }
4330 column_ids__ =
4331 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4332 .into_iter().map(|x| x.0).collect())
4333 ;
4334 }
4335 GeneratedField::VnodeBitmap => {
4336 if vnode_bitmap__.is_some() {
4337 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
4338 }
4339 vnode_bitmap__ = map_.next_value()?;
4340 }
4341 GeneratedField::OldEpoch => {
4342 if old_epoch__.is_some() {
4343 return Err(serde::de::Error::duplicate_field("oldEpoch"));
4344 }
4345 old_epoch__ = map_.next_value()?;
4346 }
4347 GeneratedField::NewEpoch => {
4348 if new_epoch__.is_some() {
4349 return Err(serde::de::Error::duplicate_field("newEpoch"));
4350 }
4351 new_epoch__ = map_.next_value()?;
4352 }
4353 GeneratedField::Ordered => {
4354 if ordered__.is_some() {
4355 return Err(serde::de::Error::duplicate_field("ordered"));
4356 }
4357 ordered__ = Some(map_.next_value()?);
4358 }
4359 GeneratedField::ScanRange => {
4360 if scan_range__.is_some() {
4361 return Err(serde::de::Error::duplicate_field("scanRange"));
4362 }
4363 scan_range__ = map_.next_value()?;
4364 }
4365 }
4366 }
4367 Ok(LogRowSeqScanNode {
4368 table_desc: table_desc__,
4369 column_ids: column_ids__.unwrap_or_default(),
4370 vnode_bitmap: vnode_bitmap__,
4371 old_epoch: old_epoch__,
4372 new_epoch: new_epoch__,
4373 ordered: ordered__.unwrap_or_default(),
4374 scan_range: scan_range__,
4375 })
4376 }
4377 }
4378 deserializer.deserialize_struct("batch_plan.LogRowSeqScanNode", FIELDS, GeneratedVisitor)
4379 }
4380}
4381impl serde::Serialize for MaxOneRowNode {
4382 #[allow(deprecated)]
4383 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4384 where
4385 S: serde::Serializer,
4386 {
4387 use serde::ser::SerializeStruct;
4388 let len = 0;
4389 let struct_ser = serializer.serialize_struct("batch_plan.MaxOneRowNode", len)?;
4390 struct_ser.end()
4391 }
4392}
4393impl<'de> serde::Deserialize<'de> for MaxOneRowNode {
4394 #[allow(deprecated)]
4395 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4396 where
4397 D: serde::Deserializer<'de>,
4398 {
4399 const FIELDS: &[&str] = &[
4400 ];
4401
4402 #[allow(clippy::enum_variant_names)]
4403 enum GeneratedField {
4404 }
4405 impl<'de> serde::Deserialize<'de> for GeneratedField {
4406 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4407 where
4408 D: serde::Deserializer<'de>,
4409 {
4410 struct GeneratedVisitor;
4411
4412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4413 type Value = GeneratedField;
4414
4415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4416 write!(formatter, "expected one of: {:?}", &FIELDS)
4417 }
4418
4419 #[allow(unused_variables)]
4420 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4421 where
4422 E: serde::de::Error,
4423 {
4424 Err(serde::de::Error::unknown_field(value, FIELDS))
4425 }
4426 }
4427 deserializer.deserialize_identifier(GeneratedVisitor)
4428 }
4429 }
4430 struct GeneratedVisitor;
4431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4432 type Value = MaxOneRowNode;
4433
4434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4435 formatter.write_str("struct batch_plan.MaxOneRowNode")
4436 }
4437
4438 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaxOneRowNode, V::Error>
4439 where
4440 V: serde::de::MapAccess<'de>,
4441 {
4442 while map_.next_key::<GeneratedField>()?.is_some() {
4443 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4444 }
4445 Ok(MaxOneRowNode {
4446 })
4447 }
4448 }
4449 deserializer.deserialize_struct("batch_plan.MaxOneRowNode", FIELDS, GeneratedVisitor)
4450 }
4451}
4452impl serde::Serialize for MergeSortExchangeNode {
4453 #[allow(deprecated)]
4454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4455 where
4456 S: serde::Serializer,
4457 {
4458 use serde::ser::SerializeStruct;
4459 let mut len = 0;
4460 if self.exchange.is_some() {
4461 len += 1;
4462 }
4463 if !self.column_orders.is_empty() {
4464 len += 1;
4465 }
4466 let mut struct_ser = serializer.serialize_struct("batch_plan.MergeSortExchangeNode", len)?;
4467 if let Some(v) = self.exchange.as_ref() {
4468 struct_ser.serialize_field("exchange", v)?;
4469 }
4470 if !self.column_orders.is_empty() {
4471 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
4472 }
4473 struct_ser.end()
4474 }
4475}
4476impl<'de> serde::Deserialize<'de> for MergeSortExchangeNode {
4477 #[allow(deprecated)]
4478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4479 where
4480 D: serde::Deserializer<'de>,
4481 {
4482 const FIELDS: &[&str] = &[
4483 "exchange",
4484 "column_orders",
4485 "columnOrders",
4486 ];
4487
4488 #[allow(clippy::enum_variant_names)]
4489 enum GeneratedField {
4490 Exchange,
4491 ColumnOrders,
4492 }
4493 impl<'de> serde::Deserialize<'de> for GeneratedField {
4494 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4495 where
4496 D: serde::Deserializer<'de>,
4497 {
4498 struct GeneratedVisitor;
4499
4500 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4501 type Value = GeneratedField;
4502
4503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4504 write!(formatter, "expected one of: {:?}", &FIELDS)
4505 }
4506
4507 #[allow(unused_variables)]
4508 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4509 where
4510 E: serde::de::Error,
4511 {
4512 match value {
4513 "exchange" => Ok(GeneratedField::Exchange),
4514 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
4515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4516 }
4517 }
4518 }
4519 deserializer.deserialize_identifier(GeneratedVisitor)
4520 }
4521 }
4522 struct GeneratedVisitor;
4523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4524 type Value = MergeSortExchangeNode;
4525
4526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4527 formatter.write_str("struct batch_plan.MergeSortExchangeNode")
4528 }
4529
4530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeSortExchangeNode, V::Error>
4531 where
4532 V: serde::de::MapAccess<'de>,
4533 {
4534 let mut exchange__ = None;
4535 let mut column_orders__ = None;
4536 while let Some(k) = map_.next_key()? {
4537 match k {
4538 GeneratedField::Exchange => {
4539 if exchange__.is_some() {
4540 return Err(serde::de::Error::duplicate_field("exchange"));
4541 }
4542 exchange__ = map_.next_value()?;
4543 }
4544 GeneratedField::ColumnOrders => {
4545 if column_orders__.is_some() {
4546 return Err(serde::de::Error::duplicate_field("columnOrders"));
4547 }
4548 column_orders__ = Some(map_.next_value()?);
4549 }
4550 }
4551 }
4552 Ok(MergeSortExchangeNode {
4553 exchange: exchange__,
4554 column_orders: column_orders__.unwrap_or_default(),
4555 })
4556 }
4557 }
4558 deserializer.deserialize_struct("batch_plan.MergeSortExchangeNode", FIELDS, GeneratedVisitor)
4559 }
4560}
4561impl serde::Serialize for MySqlQueryNode {
4562 #[allow(deprecated)]
4563 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4564 where
4565 S: serde::Serializer,
4566 {
4567 use serde::ser::SerializeStruct;
4568 let mut len = 0;
4569 if !self.columns.is_empty() {
4570 len += 1;
4571 }
4572 if !self.hostname.is_empty() {
4573 len += 1;
4574 }
4575 if !self.port.is_empty() {
4576 len += 1;
4577 }
4578 if !self.username.is_empty() {
4579 len += 1;
4580 }
4581 if !self.password.is_empty() {
4582 len += 1;
4583 }
4584 if !self.database.is_empty() {
4585 len += 1;
4586 }
4587 if !self.query.is_empty() {
4588 len += 1;
4589 }
4590 let mut struct_ser = serializer.serialize_struct("batch_plan.MySqlQueryNode", len)?;
4591 if !self.columns.is_empty() {
4592 struct_ser.serialize_field("columns", &self.columns)?;
4593 }
4594 if !self.hostname.is_empty() {
4595 struct_ser.serialize_field("hostname", &self.hostname)?;
4596 }
4597 if !self.port.is_empty() {
4598 struct_ser.serialize_field("port", &self.port)?;
4599 }
4600 if !self.username.is_empty() {
4601 struct_ser.serialize_field("username", &self.username)?;
4602 }
4603 if !self.password.is_empty() {
4604 struct_ser.serialize_field("password", &self.password)?;
4605 }
4606 if !self.database.is_empty() {
4607 struct_ser.serialize_field("database", &self.database)?;
4608 }
4609 if !self.query.is_empty() {
4610 struct_ser.serialize_field("query", &self.query)?;
4611 }
4612 struct_ser.end()
4613 }
4614}
4615impl<'de> serde::Deserialize<'de> for MySqlQueryNode {
4616 #[allow(deprecated)]
4617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4618 where
4619 D: serde::Deserializer<'de>,
4620 {
4621 const FIELDS: &[&str] = &[
4622 "columns",
4623 "hostname",
4624 "port",
4625 "username",
4626 "password",
4627 "database",
4628 "query",
4629 ];
4630
4631 #[allow(clippy::enum_variant_names)]
4632 enum GeneratedField {
4633 Columns,
4634 Hostname,
4635 Port,
4636 Username,
4637 Password,
4638 Database,
4639 Query,
4640 }
4641 impl<'de> serde::Deserialize<'de> for GeneratedField {
4642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4643 where
4644 D: serde::Deserializer<'de>,
4645 {
4646 struct GeneratedVisitor;
4647
4648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4649 type Value = GeneratedField;
4650
4651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4652 write!(formatter, "expected one of: {:?}", &FIELDS)
4653 }
4654
4655 #[allow(unused_variables)]
4656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4657 where
4658 E: serde::de::Error,
4659 {
4660 match value {
4661 "columns" => Ok(GeneratedField::Columns),
4662 "hostname" => Ok(GeneratedField::Hostname),
4663 "port" => Ok(GeneratedField::Port),
4664 "username" => Ok(GeneratedField::Username),
4665 "password" => Ok(GeneratedField::Password),
4666 "database" => Ok(GeneratedField::Database),
4667 "query" => Ok(GeneratedField::Query),
4668 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4669 }
4670 }
4671 }
4672 deserializer.deserialize_identifier(GeneratedVisitor)
4673 }
4674 }
4675 struct GeneratedVisitor;
4676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4677 type Value = MySqlQueryNode;
4678
4679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4680 formatter.write_str("struct batch_plan.MySqlQueryNode")
4681 }
4682
4683 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MySqlQueryNode, V::Error>
4684 where
4685 V: serde::de::MapAccess<'de>,
4686 {
4687 let mut columns__ = None;
4688 let mut hostname__ = None;
4689 let mut port__ = None;
4690 let mut username__ = None;
4691 let mut password__ = None;
4692 let mut database__ = None;
4693 let mut query__ = None;
4694 while let Some(k) = map_.next_key()? {
4695 match k {
4696 GeneratedField::Columns => {
4697 if columns__.is_some() {
4698 return Err(serde::de::Error::duplicate_field("columns"));
4699 }
4700 columns__ = Some(map_.next_value()?);
4701 }
4702 GeneratedField::Hostname => {
4703 if hostname__.is_some() {
4704 return Err(serde::de::Error::duplicate_field("hostname"));
4705 }
4706 hostname__ = Some(map_.next_value()?);
4707 }
4708 GeneratedField::Port => {
4709 if port__.is_some() {
4710 return Err(serde::de::Error::duplicate_field("port"));
4711 }
4712 port__ = Some(map_.next_value()?);
4713 }
4714 GeneratedField::Username => {
4715 if username__.is_some() {
4716 return Err(serde::de::Error::duplicate_field("username"));
4717 }
4718 username__ = Some(map_.next_value()?);
4719 }
4720 GeneratedField::Password => {
4721 if password__.is_some() {
4722 return Err(serde::de::Error::duplicate_field("password"));
4723 }
4724 password__ = Some(map_.next_value()?);
4725 }
4726 GeneratedField::Database => {
4727 if database__.is_some() {
4728 return Err(serde::de::Error::duplicate_field("database"));
4729 }
4730 database__ = Some(map_.next_value()?);
4731 }
4732 GeneratedField::Query => {
4733 if query__.is_some() {
4734 return Err(serde::de::Error::duplicate_field("query"));
4735 }
4736 query__ = Some(map_.next_value()?);
4737 }
4738 }
4739 }
4740 Ok(MySqlQueryNode {
4741 columns: columns__.unwrap_or_default(),
4742 hostname: hostname__.unwrap_or_default(),
4743 port: port__.unwrap_or_default(),
4744 username: username__.unwrap_or_default(),
4745 password: password__.unwrap_or_default(),
4746 database: database__.unwrap_or_default(),
4747 query: query__.unwrap_or_default(),
4748 })
4749 }
4750 }
4751 deserializer.deserialize_struct("batch_plan.MySqlQueryNode", FIELDS, GeneratedVisitor)
4752 }
4753}
4754impl serde::Serialize for NestedLoopJoinNode {
4755 #[allow(deprecated)]
4756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4757 where
4758 S: serde::Serializer,
4759 {
4760 use serde::ser::SerializeStruct;
4761 let mut len = 0;
4762 if self.join_type != 0 {
4763 len += 1;
4764 }
4765 if self.join_cond.is_some() {
4766 len += 1;
4767 }
4768 if !self.output_indices.is_empty() {
4769 len += 1;
4770 }
4771 let mut struct_ser = serializer.serialize_struct("batch_plan.NestedLoopJoinNode", len)?;
4772 if self.join_type != 0 {
4773 let v = super::plan_common::JoinType::try_from(self.join_type)
4774 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
4775 struct_ser.serialize_field("joinType", &v)?;
4776 }
4777 if let Some(v) = self.join_cond.as_ref() {
4778 struct_ser.serialize_field("joinCond", v)?;
4779 }
4780 if !self.output_indices.is_empty() {
4781 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
4782 }
4783 struct_ser.end()
4784 }
4785}
4786impl<'de> serde::Deserialize<'de> for NestedLoopJoinNode {
4787 #[allow(deprecated)]
4788 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4789 where
4790 D: serde::Deserializer<'de>,
4791 {
4792 const FIELDS: &[&str] = &[
4793 "join_type",
4794 "joinType",
4795 "join_cond",
4796 "joinCond",
4797 "output_indices",
4798 "outputIndices",
4799 ];
4800
4801 #[allow(clippy::enum_variant_names)]
4802 enum GeneratedField {
4803 JoinType,
4804 JoinCond,
4805 OutputIndices,
4806 }
4807 impl<'de> serde::Deserialize<'de> for GeneratedField {
4808 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4809 where
4810 D: serde::Deserializer<'de>,
4811 {
4812 struct GeneratedVisitor;
4813
4814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4815 type Value = GeneratedField;
4816
4817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4818 write!(formatter, "expected one of: {:?}", &FIELDS)
4819 }
4820
4821 #[allow(unused_variables)]
4822 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4823 where
4824 E: serde::de::Error,
4825 {
4826 match value {
4827 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
4828 "joinCond" | "join_cond" => Ok(GeneratedField::JoinCond),
4829 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
4830 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4831 }
4832 }
4833 }
4834 deserializer.deserialize_identifier(GeneratedVisitor)
4835 }
4836 }
4837 struct GeneratedVisitor;
4838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4839 type Value = NestedLoopJoinNode;
4840
4841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4842 formatter.write_str("struct batch_plan.NestedLoopJoinNode")
4843 }
4844
4845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NestedLoopJoinNode, V::Error>
4846 where
4847 V: serde::de::MapAccess<'de>,
4848 {
4849 let mut join_type__ = None;
4850 let mut join_cond__ = None;
4851 let mut output_indices__ = None;
4852 while let Some(k) = map_.next_key()? {
4853 match k {
4854 GeneratedField::JoinType => {
4855 if join_type__.is_some() {
4856 return Err(serde::de::Error::duplicate_field("joinType"));
4857 }
4858 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
4859 }
4860 GeneratedField::JoinCond => {
4861 if join_cond__.is_some() {
4862 return Err(serde::de::Error::duplicate_field("joinCond"));
4863 }
4864 join_cond__ = map_.next_value()?;
4865 }
4866 GeneratedField::OutputIndices => {
4867 if output_indices__.is_some() {
4868 return Err(serde::de::Error::duplicate_field("outputIndices"));
4869 }
4870 output_indices__ =
4871 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4872 .into_iter().map(|x| x.0).collect())
4873 ;
4874 }
4875 }
4876 }
4877 Ok(NestedLoopJoinNode {
4878 join_type: join_type__.unwrap_or_default(),
4879 join_cond: join_cond__,
4880 output_indices: output_indices__.unwrap_or_default(),
4881 })
4882 }
4883 }
4884 deserializer.deserialize_struct("batch_plan.NestedLoopJoinNode", FIELDS, GeneratedVisitor)
4885 }
4886}
4887impl serde::Serialize for PlanFragment {
4888 #[allow(deprecated)]
4889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4890 where
4891 S: serde::Serializer,
4892 {
4893 use serde::ser::SerializeStruct;
4894 let mut len = 0;
4895 if self.root.is_some() {
4896 len += 1;
4897 }
4898 if self.exchange_info.is_some() {
4899 len += 1;
4900 }
4901 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanFragment", len)?;
4902 if let Some(v) = self.root.as_ref() {
4903 struct_ser.serialize_field("root", v)?;
4904 }
4905 if let Some(v) = self.exchange_info.as_ref() {
4906 struct_ser.serialize_field("exchangeInfo", v)?;
4907 }
4908 struct_ser.end()
4909 }
4910}
4911impl<'de> serde::Deserialize<'de> for PlanFragment {
4912 #[allow(deprecated)]
4913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4914 where
4915 D: serde::Deserializer<'de>,
4916 {
4917 const FIELDS: &[&str] = &[
4918 "root",
4919 "exchange_info",
4920 "exchangeInfo",
4921 ];
4922
4923 #[allow(clippy::enum_variant_names)]
4924 enum GeneratedField {
4925 Root,
4926 ExchangeInfo,
4927 }
4928 impl<'de> serde::Deserialize<'de> for GeneratedField {
4929 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4930 where
4931 D: serde::Deserializer<'de>,
4932 {
4933 struct GeneratedVisitor;
4934
4935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4936 type Value = GeneratedField;
4937
4938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4939 write!(formatter, "expected one of: {:?}", &FIELDS)
4940 }
4941
4942 #[allow(unused_variables)]
4943 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4944 where
4945 E: serde::de::Error,
4946 {
4947 match value {
4948 "root" => Ok(GeneratedField::Root),
4949 "exchangeInfo" | "exchange_info" => Ok(GeneratedField::ExchangeInfo),
4950 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4951 }
4952 }
4953 }
4954 deserializer.deserialize_identifier(GeneratedVisitor)
4955 }
4956 }
4957 struct GeneratedVisitor;
4958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4959 type Value = PlanFragment;
4960
4961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4962 formatter.write_str("struct batch_plan.PlanFragment")
4963 }
4964
4965 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanFragment, V::Error>
4966 where
4967 V: serde::de::MapAccess<'de>,
4968 {
4969 let mut root__ = None;
4970 let mut exchange_info__ = None;
4971 while let Some(k) = map_.next_key()? {
4972 match k {
4973 GeneratedField::Root => {
4974 if root__.is_some() {
4975 return Err(serde::de::Error::duplicate_field("root"));
4976 }
4977 root__ = map_.next_value()?;
4978 }
4979 GeneratedField::ExchangeInfo => {
4980 if exchange_info__.is_some() {
4981 return Err(serde::de::Error::duplicate_field("exchangeInfo"));
4982 }
4983 exchange_info__ = map_.next_value()?;
4984 }
4985 }
4986 }
4987 Ok(PlanFragment {
4988 root: root__,
4989 exchange_info: exchange_info__,
4990 })
4991 }
4992 }
4993 deserializer.deserialize_struct("batch_plan.PlanFragment", FIELDS, GeneratedVisitor)
4994 }
4995}
4996impl serde::Serialize for PlanNode {
4997 #[allow(deprecated)]
4998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4999 where
5000 S: serde::Serializer,
5001 {
5002 use serde::ser::SerializeStruct;
5003 let mut len = 0;
5004 if !self.children.is_empty() {
5005 len += 1;
5006 }
5007 if !self.identity.is_empty() {
5008 len += 1;
5009 }
5010 if self.node_body.is_some() {
5011 len += 1;
5012 }
5013 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanNode", len)?;
5014 if !self.children.is_empty() {
5015 struct_ser.serialize_field("children", &self.children)?;
5016 }
5017 if !self.identity.is_empty() {
5018 struct_ser.serialize_field("identity", &self.identity)?;
5019 }
5020 if let Some(v) = self.node_body.as_ref() {
5021 match v {
5022 plan_node::NodeBody::Insert(v) => {
5023 struct_ser.serialize_field("insert", v)?;
5024 }
5025 plan_node::NodeBody::Delete(v) => {
5026 struct_ser.serialize_field("delete", v)?;
5027 }
5028 plan_node::NodeBody::Update(v) => {
5029 struct_ser.serialize_field("update", v)?;
5030 }
5031 plan_node::NodeBody::Project(v) => {
5032 struct_ser.serialize_field("project", v)?;
5033 }
5034 plan_node::NodeBody::HashAgg(v) => {
5035 struct_ser.serialize_field("hashAgg", v)?;
5036 }
5037 plan_node::NodeBody::Filter(v) => {
5038 struct_ser.serialize_field("filter", v)?;
5039 }
5040 plan_node::NodeBody::Exchange(v) => {
5041 struct_ser.serialize_field("exchange", v)?;
5042 }
5043 plan_node::NodeBody::Sort(v) => {
5044 struct_ser.serialize_field("sort", v)?;
5045 }
5046 plan_node::NodeBody::NestedLoopJoin(v) => {
5047 struct_ser.serialize_field("nestedLoopJoin", v)?;
5048 }
5049 plan_node::NodeBody::TopN(v) => {
5050 struct_ser.serialize_field("topN", v)?;
5051 }
5052 plan_node::NodeBody::SortAgg(v) => {
5053 struct_ser.serialize_field("sortAgg", v)?;
5054 }
5055 plan_node::NodeBody::RowSeqScan(v) => {
5056 struct_ser.serialize_field("rowSeqScan", v)?;
5057 }
5058 plan_node::NodeBody::Limit(v) => {
5059 struct_ser.serialize_field("limit", v)?;
5060 }
5061 plan_node::NodeBody::Values(v) => {
5062 struct_ser.serialize_field("values", v)?;
5063 }
5064 plan_node::NodeBody::HashJoin(v) => {
5065 struct_ser.serialize_field("hashJoin", v)?;
5066 }
5067 plan_node::NodeBody::MergeSortExchange(v) => {
5068 struct_ser.serialize_field("mergeSortExchange", v)?;
5069 }
5070 plan_node::NodeBody::HopWindow(v) => {
5071 struct_ser.serialize_field("hopWindow", v)?;
5072 }
5073 plan_node::NodeBody::TableFunction(v) => {
5074 struct_ser.serialize_field("tableFunction", v)?;
5075 }
5076 plan_node::NodeBody::SysRowSeqScan(v) => {
5077 struct_ser.serialize_field("sysRowSeqScan", v)?;
5078 }
5079 plan_node::NodeBody::Expand(v) => {
5080 struct_ser.serialize_field("expand", v)?;
5081 }
5082 plan_node::NodeBody::LocalLookupJoin(v) => {
5083 struct_ser.serialize_field("localLookupJoin", v)?;
5084 }
5085 plan_node::NodeBody::ProjectSet(v) => {
5086 struct_ser.serialize_field("projectSet", v)?;
5087 }
5088 plan_node::NodeBody::Union(v) => {
5089 struct_ser.serialize_field("union", v)?;
5090 }
5091 plan_node::NodeBody::GroupTopN(v) => {
5092 struct_ser.serialize_field("groupTopN", v)?;
5093 }
5094 plan_node::NodeBody::DistributedLookupJoin(v) => {
5095 struct_ser.serialize_field("distributedLookupJoin", v)?;
5096 }
5097 plan_node::NodeBody::Source(v) => {
5098 struct_ser.serialize_field("source", v)?;
5099 }
5100 plan_node::NodeBody::SortOverWindow(v) => {
5101 struct_ser.serialize_field("sortOverWindow", v)?;
5102 }
5103 plan_node::NodeBody::MaxOneRow(v) => {
5104 struct_ser.serialize_field("maxOneRow", v)?;
5105 }
5106 plan_node::NodeBody::LogRowSeqScan(v) => {
5107 struct_ser.serialize_field("logRowSeqScan", v)?;
5108 }
5109 plan_node::NodeBody::FileScan(v) => {
5110 struct_ser.serialize_field("fileScan", v)?;
5111 }
5112 plan_node::NodeBody::IcebergScan(v) => {
5113 struct_ser.serialize_field("icebergScan", v)?;
5114 }
5115 plan_node::NodeBody::PostgresQuery(v) => {
5116 struct_ser.serialize_field("postgresQuery", v)?;
5117 }
5118 plan_node::NodeBody::MysqlQuery(v) => {
5119 struct_ser.serialize_field("mysqlQuery", v)?;
5120 }
5121 plan_node::NodeBody::GcsFileScan(v) => {
5122 struct_ser.serialize_field("gcsFileScan", v)?;
5123 }
5124 plan_node::NodeBody::AzblobFileScan(v) => {
5125 struct_ser.serialize_field("azblobFileScan", v)?;
5126 }
5127 plan_node::NodeBody::VectorIndexNearest(v) => {
5128 struct_ser.serialize_field("vectorIndexNearest", v)?;
5129 }
5130 plan_node::NodeBody::GetChannelDeltaStats(v) => {
5131 struct_ser.serialize_field("getChannelDeltaStats", v)?;
5132 }
5133 plan_node::NodeBody::BlockExecutor(v) => {
5134 struct_ser.serialize_field("blockExecutor", v)?;
5135 }
5136 plan_node::NodeBody::BusyLoopExecutor(v) => {
5137 struct_ser.serialize_field("busyLoopExecutor", v)?;
5138 }
5139 }
5140 }
5141 struct_ser.end()
5142 }
5143}
5144impl<'de> serde::Deserialize<'de> for PlanNode {
5145 #[allow(deprecated)]
5146 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5147 where
5148 D: serde::Deserializer<'de>,
5149 {
5150 const FIELDS: &[&str] = &[
5151 "children",
5152 "identity",
5153 "insert",
5154 "delete",
5155 "update",
5156 "project",
5157 "hash_agg",
5158 "hashAgg",
5159 "filter",
5160 "exchange",
5161 "sort",
5162 "nested_loop_join",
5163 "nestedLoopJoin",
5164 "top_n",
5165 "topN",
5166 "sort_agg",
5167 "sortAgg",
5168 "row_seq_scan",
5169 "rowSeqScan",
5170 "limit",
5171 "values",
5172 "hash_join",
5173 "hashJoin",
5174 "merge_sort_exchange",
5175 "mergeSortExchange",
5176 "hop_window",
5177 "hopWindow",
5178 "table_function",
5179 "tableFunction",
5180 "sys_row_seq_scan",
5181 "sysRowSeqScan",
5182 "expand",
5183 "local_lookup_join",
5184 "localLookupJoin",
5185 "project_set",
5186 "projectSet",
5187 "union",
5188 "group_top_n",
5189 "groupTopN",
5190 "distributed_lookup_join",
5191 "distributedLookupJoin",
5192 "source",
5193 "sort_over_window",
5194 "sortOverWindow",
5195 "max_one_row",
5196 "maxOneRow",
5197 "log_row_seq_scan",
5198 "logRowSeqScan",
5199 "file_scan",
5200 "fileScan",
5201 "iceberg_scan",
5202 "icebergScan",
5203 "postgres_query",
5204 "postgresQuery",
5205 "mysql_query",
5206 "mysqlQuery",
5207 "gcs_file_scan",
5208 "gcsFileScan",
5209 "azblob_file_scan",
5210 "azblobFileScan",
5211 "vector_index_nearest",
5212 "vectorIndexNearest",
5213 "get_channel_delta_stats",
5214 "getChannelDeltaStats",
5215 "block_executor",
5216 "blockExecutor",
5217 "busy_loop_executor",
5218 "busyLoopExecutor",
5219 ];
5220
5221 #[allow(clippy::enum_variant_names)]
5222 enum GeneratedField {
5223 Children,
5224 Identity,
5225 Insert,
5226 Delete,
5227 Update,
5228 Project,
5229 HashAgg,
5230 Filter,
5231 Exchange,
5232 Sort,
5233 NestedLoopJoin,
5234 TopN,
5235 SortAgg,
5236 RowSeqScan,
5237 Limit,
5238 Values,
5239 HashJoin,
5240 MergeSortExchange,
5241 HopWindow,
5242 TableFunction,
5243 SysRowSeqScan,
5244 Expand,
5245 LocalLookupJoin,
5246 ProjectSet,
5247 Union,
5248 GroupTopN,
5249 DistributedLookupJoin,
5250 Source,
5251 SortOverWindow,
5252 MaxOneRow,
5253 LogRowSeqScan,
5254 FileScan,
5255 IcebergScan,
5256 PostgresQuery,
5257 MysqlQuery,
5258 GcsFileScan,
5259 AzblobFileScan,
5260 VectorIndexNearest,
5261 GetChannelDeltaStats,
5262 BlockExecutor,
5263 BusyLoopExecutor,
5264 }
5265 impl<'de> serde::Deserialize<'de> for GeneratedField {
5266 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5267 where
5268 D: serde::Deserializer<'de>,
5269 {
5270 struct GeneratedVisitor;
5271
5272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5273 type Value = GeneratedField;
5274
5275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5276 write!(formatter, "expected one of: {:?}", &FIELDS)
5277 }
5278
5279 #[allow(unused_variables)]
5280 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5281 where
5282 E: serde::de::Error,
5283 {
5284 match value {
5285 "children" => Ok(GeneratedField::Children),
5286 "identity" => Ok(GeneratedField::Identity),
5287 "insert" => Ok(GeneratedField::Insert),
5288 "delete" => Ok(GeneratedField::Delete),
5289 "update" => Ok(GeneratedField::Update),
5290 "project" => Ok(GeneratedField::Project),
5291 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
5292 "filter" => Ok(GeneratedField::Filter),
5293 "exchange" => Ok(GeneratedField::Exchange),
5294 "sort" => Ok(GeneratedField::Sort),
5295 "nestedLoopJoin" | "nested_loop_join" => Ok(GeneratedField::NestedLoopJoin),
5296 "topN" | "top_n" => Ok(GeneratedField::TopN),
5297 "sortAgg" | "sort_agg" => Ok(GeneratedField::SortAgg),
5298 "rowSeqScan" | "row_seq_scan" => Ok(GeneratedField::RowSeqScan),
5299 "limit" => Ok(GeneratedField::Limit),
5300 "values" => Ok(GeneratedField::Values),
5301 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
5302 "mergeSortExchange" | "merge_sort_exchange" => Ok(GeneratedField::MergeSortExchange),
5303 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
5304 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
5305 "sysRowSeqScan" | "sys_row_seq_scan" => Ok(GeneratedField::SysRowSeqScan),
5306 "expand" => Ok(GeneratedField::Expand),
5307 "localLookupJoin" | "local_lookup_join" => Ok(GeneratedField::LocalLookupJoin),
5308 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
5309 "union" => Ok(GeneratedField::Union),
5310 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
5311 "distributedLookupJoin" | "distributed_lookup_join" => Ok(GeneratedField::DistributedLookupJoin),
5312 "source" => Ok(GeneratedField::Source),
5313 "sortOverWindow" | "sort_over_window" => Ok(GeneratedField::SortOverWindow),
5314 "maxOneRow" | "max_one_row" => Ok(GeneratedField::MaxOneRow),
5315 "logRowSeqScan" | "log_row_seq_scan" => Ok(GeneratedField::LogRowSeqScan),
5316 "fileScan" | "file_scan" => Ok(GeneratedField::FileScan),
5317 "icebergScan" | "iceberg_scan" => Ok(GeneratedField::IcebergScan),
5318 "postgresQuery" | "postgres_query" => Ok(GeneratedField::PostgresQuery),
5319 "mysqlQuery" | "mysql_query" => Ok(GeneratedField::MysqlQuery),
5320 "gcsFileScan" | "gcs_file_scan" => Ok(GeneratedField::GcsFileScan),
5321 "azblobFileScan" | "azblob_file_scan" => Ok(GeneratedField::AzblobFileScan),
5322 "vectorIndexNearest" | "vector_index_nearest" => Ok(GeneratedField::VectorIndexNearest),
5323 "getChannelDeltaStats" | "get_channel_delta_stats" => Ok(GeneratedField::GetChannelDeltaStats),
5324 "blockExecutor" | "block_executor" => Ok(GeneratedField::BlockExecutor),
5325 "busyLoopExecutor" | "busy_loop_executor" => Ok(GeneratedField::BusyLoopExecutor),
5326 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5327 }
5328 }
5329 }
5330 deserializer.deserialize_identifier(GeneratedVisitor)
5331 }
5332 }
5333 struct GeneratedVisitor;
5334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5335 type Value = PlanNode;
5336
5337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5338 formatter.write_str("struct batch_plan.PlanNode")
5339 }
5340
5341 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanNode, V::Error>
5342 where
5343 V: serde::de::MapAccess<'de>,
5344 {
5345 let mut children__ = None;
5346 let mut identity__ = None;
5347 let mut node_body__ = None;
5348 while let Some(k) = map_.next_key()? {
5349 match k {
5350 GeneratedField::Children => {
5351 if children__.is_some() {
5352 return Err(serde::de::Error::duplicate_field("children"));
5353 }
5354 children__ = Some(map_.next_value()?);
5355 }
5356 GeneratedField::Identity => {
5357 if identity__.is_some() {
5358 return Err(serde::de::Error::duplicate_field("identity"));
5359 }
5360 identity__ = Some(map_.next_value()?);
5361 }
5362 GeneratedField::Insert => {
5363 if node_body__.is_some() {
5364 return Err(serde::de::Error::duplicate_field("insert"));
5365 }
5366 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Insert)
5367;
5368 }
5369 GeneratedField::Delete => {
5370 if node_body__.is_some() {
5371 return Err(serde::de::Error::duplicate_field("delete"));
5372 }
5373 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Delete)
5374;
5375 }
5376 GeneratedField::Update => {
5377 if node_body__.is_some() {
5378 return Err(serde::de::Error::duplicate_field("update"));
5379 }
5380 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Update)
5381;
5382 }
5383 GeneratedField::Project => {
5384 if node_body__.is_some() {
5385 return Err(serde::de::Error::duplicate_field("project"));
5386 }
5387 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Project)
5388;
5389 }
5390 GeneratedField::HashAgg => {
5391 if node_body__.is_some() {
5392 return Err(serde::de::Error::duplicate_field("hashAgg"));
5393 }
5394 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashAgg)
5395;
5396 }
5397 GeneratedField::Filter => {
5398 if node_body__.is_some() {
5399 return Err(serde::de::Error::duplicate_field("filter"));
5400 }
5401 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Filter)
5402;
5403 }
5404 GeneratedField::Exchange => {
5405 if node_body__.is_some() {
5406 return Err(serde::de::Error::duplicate_field("exchange"));
5407 }
5408 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Exchange)
5409;
5410 }
5411 GeneratedField::Sort => {
5412 if node_body__.is_some() {
5413 return Err(serde::de::Error::duplicate_field("sort"));
5414 }
5415 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Sort)
5416;
5417 }
5418 GeneratedField::NestedLoopJoin => {
5419 if node_body__.is_some() {
5420 return Err(serde::de::Error::duplicate_field("nestedLoopJoin"));
5421 }
5422 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::NestedLoopJoin)
5423;
5424 }
5425 GeneratedField::TopN => {
5426 if node_body__.is_some() {
5427 return Err(serde::de::Error::duplicate_field("topN"));
5428 }
5429 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TopN)
5430;
5431 }
5432 GeneratedField::SortAgg => {
5433 if node_body__.is_some() {
5434 return Err(serde::de::Error::duplicate_field("sortAgg"));
5435 }
5436 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortAgg)
5437;
5438 }
5439 GeneratedField::RowSeqScan => {
5440 if node_body__.is_some() {
5441 return Err(serde::de::Error::duplicate_field("rowSeqScan"));
5442 }
5443 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::RowSeqScan)
5444;
5445 }
5446 GeneratedField::Limit => {
5447 if node_body__.is_some() {
5448 return Err(serde::de::Error::duplicate_field("limit"));
5449 }
5450 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Limit)
5451;
5452 }
5453 GeneratedField::Values => {
5454 if node_body__.is_some() {
5455 return Err(serde::de::Error::duplicate_field("values"));
5456 }
5457 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Values)
5458;
5459 }
5460 GeneratedField::HashJoin => {
5461 if node_body__.is_some() {
5462 return Err(serde::de::Error::duplicate_field("hashJoin"));
5463 }
5464 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashJoin)
5465;
5466 }
5467 GeneratedField::MergeSortExchange => {
5468 if node_body__.is_some() {
5469 return Err(serde::de::Error::duplicate_field("mergeSortExchange"));
5470 }
5471 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MergeSortExchange)
5472;
5473 }
5474 GeneratedField::HopWindow => {
5475 if node_body__.is_some() {
5476 return Err(serde::de::Error::duplicate_field("hopWindow"));
5477 }
5478 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HopWindow)
5479;
5480 }
5481 GeneratedField::TableFunction => {
5482 if node_body__.is_some() {
5483 return Err(serde::de::Error::duplicate_field("tableFunction"));
5484 }
5485 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TableFunction)
5486;
5487 }
5488 GeneratedField::SysRowSeqScan => {
5489 if node_body__.is_some() {
5490 return Err(serde::de::Error::duplicate_field("sysRowSeqScan"));
5491 }
5492 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SysRowSeqScan)
5493;
5494 }
5495 GeneratedField::Expand => {
5496 if node_body__.is_some() {
5497 return Err(serde::de::Error::duplicate_field("expand"));
5498 }
5499 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Expand)
5500;
5501 }
5502 GeneratedField::LocalLookupJoin => {
5503 if node_body__.is_some() {
5504 return Err(serde::de::Error::duplicate_field("localLookupJoin"));
5505 }
5506 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LocalLookupJoin)
5507;
5508 }
5509 GeneratedField::ProjectSet => {
5510 if node_body__.is_some() {
5511 return Err(serde::de::Error::duplicate_field("projectSet"));
5512 }
5513 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::ProjectSet)
5514;
5515 }
5516 GeneratedField::Union => {
5517 if node_body__.is_some() {
5518 return Err(serde::de::Error::duplicate_field("union"));
5519 }
5520 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Union)
5521;
5522 }
5523 GeneratedField::GroupTopN => {
5524 if node_body__.is_some() {
5525 return Err(serde::de::Error::duplicate_field("groupTopN"));
5526 }
5527 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GroupTopN)
5528;
5529 }
5530 GeneratedField::DistributedLookupJoin => {
5531 if node_body__.is_some() {
5532 return Err(serde::de::Error::duplicate_field("distributedLookupJoin"));
5533 }
5534 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::DistributedLookupJoin)
5535;
5536 }
5537 GeneratedField::Source => {
5538 if node_body__.is_some() {
5539 return Err(serde::de::Error::duplicate_field("source"));
5540 }
5541 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Source)
5542;
5543 }
5544 GeneratedField::SortOverWindow => {
5545 if node_body__.is_some() {
5546 return Err(serde::de::Error::duplicate_field("sortOverWindow"));
5547 }
5548 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortOverWindow)
5549;
5550 }
5551 GeneratedField::MaxOneRow => {
5552 if node_body__.is_some() {
5553 return Err(serde::de::Error::duplicate_field("maxOneRow"));
5554 }
5555 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MaxOneRow)
5556;
5557 }
5558 GeneratedField::LogRowSeqScan => {
5559 if node_body__.is_some() {
5560 return Err(serde::de::Error::duplicate_field("logRowSeqScan"));
5561 }
5562 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LogRowSeqScan)
5563;
5564 }
5565 GeneratedField::FileScan => {
5566 if node_body__.is_some() {
5567 return Err(serde::de::Error::duplicate_field("fileScan"));
5568 }
5569 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::FileScan)
5570;
5571 }
5572 GeneratedField::IcebergScan => {
5573 if node_body__.is_some() {
5574 return Err(serde::de::Error::duplicate_field("icebergScan"));
5575 }
5576 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergScan)
5577;
5578 }
5579 GeneratedField::PostgresQuery => {
5580 if node_body__.is_some() {
5581 return Err(serde::de::Error::duplicate_field("postgresQuery"));
5582 }
5583 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::PostgresQuery)
5584;
5585 }
5586 GeneratedField::MysqlQuery => {
5587 if node_body__.is_some() {
5588 return Err(serde::de::Error::duplicate_field("mysqlQuery"));
5589 }
5590 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MysqlQuery)
5591;
5592 }
5593 GeneratedField::GcsFileScan => {
5594 if node_body__.is_some() {
5595 return Err(serde::de::Error::duplicate_field("gcsFileScan"));
5596 }
5597 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GcsFileScan)
5598;
5599 }
5600 GeneratedField::AzblobFileScan => {
5601 if node_body__.is_some() {
5602 return Err(serde::de::Error::duplicate_field("azblobFileScan"));
5603 }
5604 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::AzblobFileScan)
5605;
5606 }
5607 GeneratedField::VectorIndexNearest => {
5608 if node_body__.is_some() {
5609 return Err(serde::de::Error::duplicate_field("vectorIndexNearest"));
5610 }
5611 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::VectorIndexNearest)
5612;
5613 }
5614 GeneratedField::GetChannelDeltaStats => {
5615 if node_body__.is_some() {
5616 return Err(serde::de::Error::duplicate_field("getChannelDeltaStats"));
5617 }
5618 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GetChannelDeltaStats)
5619;
5620 }
5621 GeneratedField::BlockExecutor => {
5622 if node_body__.is_some() {
5623 return Err(serde::de::Error::duplicate_field("blockExecutor"));
5624 }
5625 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BlockExecutor);
5626 }
5627 GeneratedField::BusyLoopExecutor => {
5628 if node_body__.is_some() {
5629 return Err(serde::de::Error::duplicate_field("busyLoopExecutor"));
5630 }
5631 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BusyLoopExecutor);
5632 }
5633 }
5634 }
5635 Ok(PlanNode {
5636 children: children__.unwrap_or_default(),
5637 identity: identity__.unwrap_or_default(),
5638 node_body: node_body__,
5639 })
5640 }
5641 }
5642 deserializer.deserialize_struct("batch_plan.PlanNode", FIELDS, GeneratedVisitor)
5643 }
5644}
5645impl serde::Serialize for PostgresQueryNode {
5646 #[allow(deprecated)]
5647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5648 where
5649 S: serde::Serializer,
5650 {
5651 use serde::ser::SerializeStruct;
5652 let mut len = 0;
5653 if !self.columns.is_empty() {
5654 len += 1;
5655 }
5656 if !self.hostname.is_empty() {
5657 len += 1;
5658 }
5659 if !self.port.is_empty() {
5660 len += 1;
5661 }
5662 if !self.username.is_empty() {
5663 len += 1;
5664 }
5665 if !self.password.is_empty() {
5666 len += 1;
5667 }
5668 if !self.database.is_empty() {
5669 len += 1;
5670 }
5671 if !self.query.is_empty() {
5672 len += 1;
5673 }
5674 let mut struct_ser = serializer.serialize_struct("batch_plan.PostgresQueryNode", len)?;
5675 if !self.columns.is_empty() {
5676 struct_ser.serialize_field("columns", &self.columns)?;
5677 }
5678 if !self.hostname.is_empty() {
5679 struct_ser.serialize_field("hostname", &self.hostname)?;
5680 }
5681 if !self.port.is_empty() {
5682 struct_ser.serialize_field("port", &self.port)?;
5683 }
5684 if !self.username.is_empty() {
5685 struct_ser.serialize_field("username", &self.username)?;
5686 }
5687 if !self.password.is_empty() {
5688 struct_ser.serialize_field("password", &self.password)?;
5689 }
5690 if !self.database.is_empty() {
5691 struct_ser.serialize_field("database", &self.database)?;
5692 }
5693 if !self.query.is_empty() {
5694 struct_ser.serialize_field("query", &self.query)?;
5695 }
5696 struct_ser.end()
5697 }
5698}
5699impl<'de> serde::Deserialize<'de> for PostgresQueryNode {
5700 #[allow(deprecated)]
5701 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5702 where
5703 D: serde::Deserializer<'de>,
5704 {
5705 const FIELDS: &[&str] = &[
5706 "columns",
5707 "hostname",
5708 "port",
5709 "username",
5710 "password",
5711 "database",
5712 "query",
5713 ];
5714
5715 #[allow(clippy::enum_variant_names)]
5716 enum GeneratedField {
5717 Columns,
5718 Hostname,
5719 Port,
5720 Username,
5721 Password,
5722 Database,
5723 Query,
5724 }
5725 impl<'de> serde::Deserialize<'de> for GeneratedField {
5726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5727 where
5728 D: serde::Deserializer<'de>,
5729 {
5730 struct GeneratedVisitor;
5731
5732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5733 type Value = GeneratedField;
5734
5735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5736 write!(formatter, "expected one of: {:?}", &FIELDS)
5737 }
5738
5739 #[allow(unused_variables)]
5740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5741 where
5742 E: serde::de::Error,
5743 {
5744 match value {
5745 "columns" => Ok(GeneratedField::Columns),
5746 "hostname" => Ok(GeneratedField::Hostname),
5747 "port" => Ok(GeneratedField::Port),
5748 "username" => Ok(GeneratedField::Username),
5749 "password" => Ok(GeneratedField::Password),
5750 "database" => Ok(GeneratedField::Database),
5751 "query" => Ok(GeneratedField::Query),
5752 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5753 }
5754 }
5755 }
5756 deserializer.deserialize_identifier(GeneratedVisitor)
5757 }
5758 }
5759 struct GeneratedVisitor;
5760 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5761 type Value = PostgresQueryNode;
5762
5763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5764 formatter.write_str("struct batch_plan.PostgresQueryNode")
5765 }
5766
5767 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PostgresQueryNode, V::Error>
5768 where
5769 V: serde::de::MapAccess<'de>,
5770 {
5771 let mut columns__ = None;
5772 let mut hostname__ = None;
5773 let mut port__ = None;
5774 let mut username__ = None;
5775 let mut password__ = None;
5776 let mut database__ = None;
5777 let mut query__ = None;
5778 while let Some(k) = map_.next_key()? {
5779 match k {
5780 GeneratedField::Columns => {
5781 if columns__.is_some() {
5782 return Err(serde::de::Error::duplicate_field("columns"));
5783 }
5784 columns__ = Some(map_.next_value()?);
5785 }
5786 GeneratedField::Hostname => {
5787 if hostname__.is_some() {
5788 return Err(serde::de::Error::duplicate_field("hostname"));
5789 }
5790 hostname__ = Some(map_.next_value()?);
5791 }
5792 GeneratedField::Port => {
5793 if port__.is_some() {
5794 return Err(serde::de::Error::duplicate_field("port"));
5795 }
5796 port__ = Some(map_.next_value()?);
5797 }
5798 GeneratedField::Username => {
5799 if username__.is_some() {
5800 return Err(serde::de::Error::duplicate_field("username"));
5801 }
5802 username__ = Some(map_.next_value()?);
5803 }
5804 GeneratedField::Password => {
5805 if password__.is_some() {
5806 return Err(serde::de::Error::duplicate_field("password"));
5807 }
5808 password__ = Some(map_.next_value()?);
5809 }
5810 GeneratedField::Database => {
5811 if database__.is_some() {
5812 return Err(serde::de::Error::duplicate_field("database"));
5813 }
5814 database__ = Some(map_.next_value()?);
5815 }
5816 GeneratedField::Query => {
5817 if query__.is_some() {
5818 return Err(serde::de::Error::duplicate_field("query"));
5819 }
5820 query__ = Some(map_.next_value()?);
5821 }
5822 }
5823 }
5824 Ok(PostgresQueryNode {
5825 columns: columns__.unwrap_or_default(),
5826 hostname: hostname__.unwrap_or_default(),
5827 port: port__.unwrap_or_default(),
5828 username: username__.unwrap_or_default(),
5829 password: password__.unwrap_or_default(),
5830 database: database__.unwrap_or_default(),
5831 query: query__.unwrap_or_default(),
5832 })
5833 }
5834 }
5835 deserializer.deserialize_struct("batch_plan.PostgresQueryNode", FIELDS, GeneratedVisitor)
5836 }
5837}
5838impl serde::Serialize for ProjectNode {
5839 #[allow(deprecated)]
5840 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5841 where
5842 S: serde::Serializer,
5843 {
5844 use serde::ser::SerializeStruct;
5845 let mut len = 0;
5846 if !self.select_list.is_empty() {
5847 len += 1;
5848 }
5849 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectNode", len)?;
5850 if !self.select_list.is_empty() {
5851 struct_ser.serialize_field("selectList", &self.select_list)?;
5852 }
5853 struct_ser.end()
5854 }
5855}
5856impl<'de> serde::Deserialize<'de> for ProjectNode {
5857 #[allow(deprecated)]
5858 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5859 where
5860 D: serde::Deserializer<'de>,
5861 {
5862 const FIELDS: &[&str] = &[
5863 "select_list",
5864 "selectList",
5865 ];
5866
5867 #[allow(clippy::enum_variant_names)]
5868 enum GeneratedField {
5869 SelectList,
5870 }
5871 impl<'de> serde::Deserialize<'de> for GeneratedField {
5872 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5873 where
5874 D: serde::Deserializer<'de>,
5875 {
5876 struct GeneratedVisitor;
5877
5878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5879 type Value = GeneratedField;
5880
5881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5882 write!(formatter, "expected one of: {:?}", &FIELDS)
5883 }
5884
5885 #[allow(unused_variables)]
5886 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5887 where
5888 E: serde::de::Error,
5889 {
5890 match value {
5891 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5892 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5893 }
5894 }
5895 }
5896 deserializer.deserialize_identifier(GeneratedVisitor)
5897 }
5898 }
5899 struct GeneratedVisitor;
5900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5901 type Value = ProjectNode;
5902
5903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5904 formatter.write_str("struct batch_plan.ProjectNode")
5905 }
5906
5907 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
5908 where
5909 V: serde::de::MapAccess<'de>,
5910 {
5911 let mut select_list__ = None;
5912 while let Some(k) = map_.next_key()? {
5913 match k {
5914 GeneratedField::SelectList => {
5915 if select_list__.is_some() {
5916 return Err(serde::de::Error::duplicate_field("selectList"));
5917 }
5918 select_list__ = Some(map_.next_value()?);
5919 }
5920 }
5921 }
5922 Ok(ProjectNode {
5923 select_list: select_list__.unwrap_or_default(),
5924 })
5925 }
5926 }
5927 deserializer.deserialize_struct("batch_plan.ProjectNode", FIELDS, GeneratedVisitor)
5928 }
5929}
5930impl serde::Serialize for ProjectSetNode {
5931 #[allow(deprecated)]
5932 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5933 where
5934 S: serde::Serializer,
5935 {
5936 use serde::ser::SerializeStruct;
5937 let mut len = 0;
5938 if !self.select_list.is_empty() {
5939 len += 1;
5940 }
5941 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectSetNode", len)?;
5942 if !self.select_list.is_empty() {
5943 struct_ser.serialize_field("selectList", &self.select_list)?;
5944 }
5945 struct_ser.end()
5946 }
5947}
5948impl<'de> serde::Deserialize<'de> for ProjectSetNode {
5949 #[allow(deprecated)]
5950 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5951 where
5952 D: serde::Deserializer<'de>,
5953 {
5954 const FIELDS: &[&str] = &[
5955 "select_list",
5956 "selectList",
5957 ];
5958
5959 #[allow(clippy::enum_variant_names)]
5960 enum GeneratedField {
5961 SelectList,
5962 }
5963 impl<'de> serde::Deserialize<'de> for GeneratedField {
5964 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5965 where
5966 D: serde::Deserializer<'de>,
5967 {
5968 struct GeneratedVisitor;
5969
5970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5971 type Value = GeneratedField;
5972
5973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5974 write!(formatter, "expected one of: {:?}", &FIELDS)
5975 }
5976
5977 #[allow(unused_variables)]
5978 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5979 where
5980 E: serde::de::Error,
5981 {
5982 match value {
5983 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5984 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5985 }
5986 }
5987 }
5988 deserializer.deserialize_identifier(GeneratedVisitor)
5989 }
5990 }
5991 struct GeneratedVisitor;
5992 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5993 type Value = ProjectSetNode;
5994
5995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5996 formatter.write_str("struct batch_plan.ProjectSetNode")
5997 }
5998
5999 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
6000 where
6001 V: serde::de::MapAccess<'de>,
6002 {
6003 let mut select_list__ = None;
6004 while let Some(k) = map_.next_key()? {
6005 match k {
6006 GeneratedField::SelectList => {
6007 if select_list__.is_some() {
6008 return Err(serde::de::Error::duplicate_field("selectList"));
6009 }
6010 select_list__ = Some(map_.next_value()?);
6011 }
6012 }
6013 }
6014 Ok(ProjectSetNode {
6015 select_list: select_list__.unwrap_or_default(),
6016 })
6017 }
6018 }
6019 deserializer.deserialize_struct("batch_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
6020 }
6021}
6022impl serde::Serialize for RowSeqScanNode {
6023 #[allow(deprecated)]
6024 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6025 where
6026 S: serde::Serializer,
6027 {
6028 use serde::ser::SerializeStruct;
6029 let mut len = 0;
6030 if self.table_desc.is_some() {
6031 len += 1;
6032 }
6033 if !self.column_ids.is_empty() {
6034 len += 1;
6035 }
6036 if !self.scan_ranges.is_empty() {
6037 len += 1;
6038 }
6039 if self.vnode_bitmap.is_some() {
6040 len += 1;
6041 }
6042 if self.ordered {
6043 len += 1;
6044 }
6045 if self.limit.is_some() {
6046 len += 1;
6047 }
6048 if self.query_epoch.is_some() {
6049 len += 1;
6050 }
6051 let mut struct_ser = serializer.serialize_struct("batch_plan.RowSeqScanNode", len)?;
6052 if let Some(v) = self.table_desc.as_ref() {
6053 struct_ser.serialize_field("tableDesc", v)?;
6054 }
6055 if !self.column_ids.is_empty() {
6056 struct_ser.serialize_field("columnIds", &self.column_ids)?;
6057 }
6058 if !self.scan_ranges.is_empty() {
6059 struct_ser.serialize_field("scanRanges", &self.scan_ranges)?;
6060 }
6061 if let Some(v) = self.vnode_bitmap.as_ref() {
6062 struct_ser.serialize_field("vnodeBitmap", v)?;
6063 }
6064 if self.ordered {
6065 struct_ser.serialize_field("ordered", &self.ordered)?;
6066 }
6067 if let Some(v) = self.limit.as_ref() {
6068 #[allow(clippy::needless_borrow)]
6069 #[allow(clippy::needless_borrows_for_generic_args)]
6070 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
6071 }
6072 if let Some(v) = self.query_epoch.as_ref() {
6073 struct_ser.serialize_field("queryEpoch", v)?;
6074 }
6075 struct_ser.end()
6076 }
6077}
6078impl<'de> serde::Deserialize<'de> for RowSeqScanNode {
6079 #[allow(deprecated)]
6080 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6081 where
6082 D: serde::Deserializer<'de>,
6083 {
6084 const FIELDS: &[&str] = &[
6085 "table_desc",
6086 "tableDesc",
6087 "column_ids",
6088 "columnIds",
6089 "scan_ranges",
6090 "scanRanges",
6091 "vnode_bitmap",
6092 "vnodeBitmap",
6093 "ordered",
6094 "limit",
6095 "query_epoch",
6096 "queryEpoch",
6097 ];
6098
6099 #[allow(clippy::enum_variant_names)]
6100 enum GeneratedField {
6101 TableDesc,
6102 ColumnIds,
6103 ScanRanges,
6104 VnodeBitmap,
6105 Ordered,
6106 Limit,
6107 QueryEpoch,
6108 }
6109 impl<'de> serde::Deserialize<'de> for GeneratedField {
6110 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6111 where
6112 D: serde::Deserializer<'de>,
6113 {
6114 struct GeneratedVisitor;
6115
6116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6117 type Value = GeneratedField;
6118
6119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6120 write!(formatter, "expected one of: {:?}", &FIELDS)
6121 }
6122
6123 #[allow(unused_variables)]
6124 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6125 where
6126 E: serde::de::Error,
6127 {
6128 match value {
6129 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
6130 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
6131 "scanRanges" | "scan_ranges" => Ok(GeneratedField::ScanRanges),
6132 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
6133 "ordered" => Ok(GeneratedField::Ordered),
6134 "limit" => Ok(GeneratedField::Limit),
6135 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
6136 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6137 }
6138 }
6139 }
6140 deserializer.deserialize_identifier(GeneratedVisitor)
6141 }
6142 }
6143 struct GeneratedVisitor;
6144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6145 type Value = RowSeqScanNode;
6146
6147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6148 formatter.write_str("struct batch_plan.RowSeqScanNode")
6149 }
6150
6151 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowSeqScanNode, V::Error>
6152 where
6153 V: serde::de::MapAccess<'de>,
6154 {
6155 let mut table_desc__ = None;
6156 let mut column_ids__ = None;
6157 let mut scan_ranges__ = None;
6158 let mut vnode_bitmap__ = None;
6159 let mut ordered__ = None;
6160 let mut limit__ = None;
6161 let mut query_epoch__ = None;
6162 while let Some(k) = map_.next_key()? {
6163 match k {
6164 GeneratedField::TableDesc => {
6165 if table_desc__.is_some() {
6166 return Err(serde::de::Error::duplicate_field("tableDesc"));
6167 }
6168 table_desc__ = map_.next_value()?;
6169 }
6170 GeneratedField::ColumnIds => {
6171 if column_ids__.is_some() {
6172 return Err(serde::de::Error::duplicate_field("columnIds"));
6173 }
6174 column_ids__ =
6175 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6176 .into_iter().map(|x| x.0).collect())
6177 ;
6178 }
6179 GeneratedField::ScanRanges => {
6180 if scan_ranges__.is_some() {
6181 return Err(serde::de::Error::duplicate_field("scanRanges"));
6182 }
6183 scan_ranges__ = Some(map_.next_value()?);
6184 }
6185 GeneratedField::VnodeBitmap => {
6186 if vnode_bitmap__.is_some() {
6187 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
6188 }
6189 vnode_bitmap__ = map_.next_value()?;
6190 }
6191 GeneratedField::Ordered => {
6192 if ordered__.is_some() {
6193 return Err(serde::de::Error::duplicate_field("ordered"));
6194 }
6195 ordered__ = Some(map_.next_value()?);
6196 }
6197 GeneratedField::Limit => {
6198 if limit__.is_some() {
6199 return Err(serde::de::Error::duplicate_field("limit"));
6200 }
6201 limit__ =
6202 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6203 ;
6204 }
6205 GeneratedField::QueryEpoch => {
6206 if query_epoch__.is_some() {
6207 return Err(serde::de::Error::duplicate_field("queryEpoch"));
6208 }
6209 query_epoch__ = map_.next_value()?;
6210 }
6211 }
6212 }
6213 Ok(RowSeqScanNode {
6214 table_desc: table_desc__,
6215 column_ids: column_ids__.unwrap_or_default(),
6216 scan_ranges: scan_ranges__.unwrap_or_default(),
6217 vnode_bitmap: vnode_bitmap__,
6218 ordered: ordered__.unwrap_or_default(),
6219 limit: limit__,
6220 query_epoch: query_epoch__,
6221 })
6222 }
6223 }
6224 deserializer.deserialize_struct("batch_plan.RowSeqScanNode", FIELDS, GeneratedVisitor)
6225 }
6226}
6227impl serde::Serialize for ScanRange {
6228 #[allow(deprecated)]
6229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6230 where
6231 S: serde::Serializer,
6232 {
6233 use serde::ser::SerializeStruct;
6234 let mut len = 0;
6235 if !self.eq_conds.is_empty() {
6236 len += 1;
6237 }
6238 if self.lower_bound.is_some() {
6239 len += 1;
6240 }
6241 if self.upper_bound.is_some() {
6242 len += 1;
6243 }
6244 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange", len)?;
6245 if !self.eq_conds.is_empty() {
6246 struct_ser.serialize_field("eqConds", &self.eq_conds.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6247 }
6248 if let Some(v) = self.lower_bound.as_ref() {
6249 struct_ser.serialize_field("lowerBound", v)?;
6250 }
6251 if let Some(v) = self.upper_bound.as_ref() {
6252 struct_ser.serialize_field("upperBound", v)?;
6253 }
6254 struct_ser.end()
6255 }
6256}
6257impl<'de> serde::Deserialize<'de> for ScanRange {
6258 #[allow(deprecated)]
6259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6260 where
6261 D: serde::Deserializer<'de>,
6262 {
6263 const FIELDS: &[&str] = &[
6264 "eq_conds",
6265 "eqConds",
6266 "lower_bound",
6267 "lowerBound",
6268 "upper_bound",
6269 "upperBound",
6270 ];
6271
6272 #[allow(clippy::enum_variant_names)]
6273 enum GeneratedField {
6274 EqConds,
6275 LowerBound,
6276 UpperBound,
6277 }
6278 impl<'de> serde::Deserialize<'de> for GeneratedField {
6279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6280 where
6281 D: serde::Deserializer<'de>,
6282 {
6283 struct GeneratedVisitor;
6284
6285 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6286 type Value = GeneratedField;
6287
6288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6289 write!(formatter, "expected one of: {:?}", &FIELDS)
6290 }
6291
6292 #[allow(unused_variables)]
6293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6294 where
6295 E: serde::de::Error,
6296 {
6297 match value {
6298 "eqConds" | "eq_conds" => Ok(GeneratedField::EqConds),
6299 "lowerBound" | "lower_bound" => Ok(GeneratedField::LowerBound),
6300 "upperBound" | "upper_bound" => Ok(GeneratedField::UpperBound),
6301 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6302 }
6303 }
6304 }
6305 deserializer.deserialize_identifier(GeneratedVisitor)
6306 }
6307 }
6308 struct GeneratedVisitor;
6309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6310 type Value = ScanRange;
6311
6312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6313 formatter.write_str("struct batch_plan.ScanRange")
6314 }
6315
6316 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScanRange, V::Error>
6317 where
6318 V: serde::de::MapAccess<'de>,
6319 {
6320 let mut eq_conds__ = None;
6321 let mut lower_bound__ = None;
6322 let mut upper_bound__ = None;
6323 while let Some(k) = map_.next_key()? {
6324 match k {
6325 GeneratedField::EqConds => {
6326 if eq_conds__.is_some() {
6327 return Err(serde::de::Error::duplicate_field("eqConds"));
6328 }
6329 eq_conds__ =
6330 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6331 .into_iter().map(|x| x.0).collect())
6332 ;
6333 }
6334 GeneratedField::LowerBound => {
6335 if lower_bound__.is_some() {
6336 return Err(serde::de::Error::duplicate_field("lowerBound"));
6337 }
6338 lower_bound__ = map_.next_value()?;
6339 }
6340 GeneratedField::UpperBound => {
6341 if upper_bound__.is_some() {
6342 return Err(serde::de::Error::duplicate_field("upperBound"));
6343 }
6344 upper_bound__ = map_.next_value()?;
6345 }
6346 }
6347 }
6348 Ok(ScanRange {
6349 eq_conds: eq_conds__.unwrap_or_default(),
6350 lower_bound: lower_bound__,
6351 upper_bound: upper_bound__,
6352 })
6353 }
6354 }
6355 deserializer.deserialize_struct("batch_plan.ScanRange", FIELDS, GeneratedVisitor)
6356 }
6357}
6358impl serde::Serialize for scan_range::Bound {
6359 #[allow(deprecated)]
6360 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6361 where
6362 S: serde::Serializer,
6363 {
6364 use serde::ser::SerializeStruct;
6365 let mut len = 0;
6366 if !self.value.is_empty() {
6367 len += 1;
6368 }
6369 if self.inclusive {
6370 len += 1;
6371 }
6372 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange.Bound", len)?;
6373 if !self.value.is_empty() {
6374 struct_ser.serialize_field("value", &self.value.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6375 }
6376 if self.inclusive {
6377 struct_ser.serialize_field("inclusive", &self.inclusive)?;
6378 }
6379 struct_ser.end()
6380 }
6381}
6382impl<'de> serde::Deserialize<'de> for scan_range::Bound {
6383 #[allow(deprecated)]
6384 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6385 where
6386 D: serde::Deserializer<'de>,
6387 {
6388 const FIELDS: &[&str] = &[
6389 "value",
6390 "inclusive",
6391 ];
6392
6393 #[allow(clippy::enum_variant_names)]
6394 enum GeneratedField {
6395 Value,
6396 Inclusive,
6397 }
6398 impl<'de> serde::Deserialize<'de> for GeneratedField {
6399 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6400 where
6401 D: serde::Deserializer<'de>,
6402 {
6403 struct GeneratedVisitor;
6404
6405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6406 type Value = GeneratedField;
6407
6408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6409 write!(formatter, "expected one of: {:?}", &FIELDS)
6410 }
6411
6412 #[allow(unused_variables)]
6413 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6414 where
6415 E: serde::de::Error,
6416 {
6417 match value {
6418 "value" => Ok(GeneratedField::Value),
6419 "inclusive" => Ok(GeneratedField::Inclusive),
6420 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6421 }
6422 }
6423 }
6424 deserializer.deserialize_identifier(GeneratedVisitor)
6425 }
6426 }
6427 struct GeneratedVisitor;
6428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6429 type Value = scan_range::Bound;
6430
6431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6432 formatter.write_str("struct batch_plan.ScanRange.Bound")
6433 }
6434
6435 fn visit_map<V>(self, mut map_: V) -> std::result::Result<scan_range::Bound, V::Error>
6436 where
6437 V: serde::de::MapAccess<'de>,
6438 {
6439 let mut value__ = None;
6440 let mut inclusive__ = None;
6441 while let Some(k) = map_.next_key()? {
6442 match k {
6443 GeneratedField::Value => {
6444 if value__.is_some() {
6445 return Err(serde::de::Error::duplicate_field("value"));
6446 }
6447 value__ =
6448 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6449 .into_iter().map(|x| x.0).collect())
6450 ;
6451 }
6452 GeneratedField::Inclusive => {
6453 if inclusive__.is_some() {
6454 return Err(serde::de::Error::duplicate_field("inclusive"));
6455 }
6456 inclusive__ = Some(map_.next_value()?);
6457 }
6458 }
6459 }
6460 Ok(scan_range::Bound {
6461 value: value__.unwrap_or_default(),
6462 inclusive: inclusive__.unwrap_or_default(),
6463 })
6464 }
6465 }
6466 deserializer.deserialize_struct("batch_plan.ScanRange.Bound", FIELDS, GeneratedVisitor)
6467 }
6468}
6469impl serde::Serialize for SortAggNode {
6470 #[allow(deprecated)]
6471 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6472 where
6473 S: serde::Serializer,
6474 {
6475 use serde::ser::SerializeStruct;
6476 let mut len = 0;
6477 if !self.group_key.is_empty() {
6478 len += 1;
6479 }
6480 if !self.agg_calls.is_empty() {
6481 len += 1;
6482 }
6483 let mut struct_ser = serializer.serialize_struct("batch_plan.SortAggNode", len)?;
6484 if !self.group_key.is_empty() {
6485 struct_ser.serialize_field("groupKey", &self.group_key)?;
6486 }
6487 if !self.agg_calls.is_empty() {
6488 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6489 }
6490 struct_ser.end()
6491 }
6492}
6493impl<'de> serde::Deserialize<'de> for SortAggNode {
6494 #[allow(deprecated)]
6495 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6496 where
6497 D: serde::Deserializer<'de>,
6498 {
6499 const FIELDS: &[&str] = &[
6500 "group_key",
6501 "groupKey",
6502 "agg_calls",
6503 "aggCalls",
6504 ];
6505
6506 #[allow(clippy::enum_variant_names)]
6507 enum GeneratedField {
6508 GroupKey,
6509 AggCalls,
6510 }
6511 impl<'de> serde::Deserialize<'de> for GeneratedField {
6512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6513 where
6514 D: serde::Deserializer<'de>,
6515 {
6516 struct GeneratedVisitor;
6517
6518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6519 type Value = GeneratedField;
6520
6521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6522 write!(formatter, "expected one of: {:?}", &FIELDS)
6523 }
6524
6525 #[allow(unused_variables)]
6526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6527 where
6528 E: serde::de::Error,
6529 {
6530 match value {
6531 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6532 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6534 }
6535 }
6536 }
6537 deserializer.deserialize_identifier(GeneratedVisitor)
6538 }
6539 }
6540 struct GeneratedVisitor;
6541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6542 type Value = SortAggNode;
6543
6544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6545 formatter.write_str("struct batch_plan.SortAggNode")
6546 }
6547
6548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortAggNode, V::Error>
6549 where
6550 V: serde::de::MapAccess<'de>,
6551 {
6552 let mut group_key__ = None;
6553 let mut agg_calls__ = None;
6554 while let Some(k) = map_.next_key()? {
6555 match k {
6556 GeneratedField::GroupKey => {
6557 if group_key__.is_some() {
6558 return Err(serde::de::Error::duplicate_field("groupKey"));
6559 }
6560 group_key__ = Some(map_.next_value()?);
6561 }
6562 GeneratedField::AggCalls => {
6563 if agg_calls__.is_some() {
6564 return Err(serde::de::Error::duplicate_field("aggCalls"));
6565 }
6566 agg_calls__ = Some(map_.next_value()?);
6567 }
6568 }
6569 }
6570 Ok(SortAggNode {
6571 group_key: group_key__.unwrap_or_default(),
6572 agg_calls: agg_calls__.unwrap_or_default(),
6573 })
6574 }
6575 }
6576 deserializer.deserialize_struct("batch_plan.SortAggNode", FIELDS, GeneratedVisitor)
6577 }
6578}
6579impl serde::Serialize for SortMergeJoinNode {
6580 #[allow(deprecated)]
6581 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6582 where
6583 S: serde::Serializer,
6584 {
6585 use serde::ser::SerializeStruct;
6586 let mut len = 0;
6587 if self.join_type != 0 {
6588 len += 1;
6589 }
6590 if !self.left_key.is_empty() {
6591 len += 1;
6592 }
6593 if !self.right_key.is_empty() {
6594 len += 1;
6595 }
6596 if self.direction != 0 {
6597 len += 1;
6598 }
6599 if !self.output_indices.is_empty() {
6600 len += 1;
6601 }
6602 let mut struct_ser = serializer.serialize_struct("batch_plan.SortMergeJoinNode", len)?;
6603 if self.join_type != 0 {
6604 let v = super::plan_common::JoinType::try_from(self.join_type)
6605 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6606 struct_ser.serialize_field("joinType", &v)?;
6607 }
6608 if !self.left_key.is_empty() {
6609 struct_ser.serialize_field("leftKey", &self.left_key)?;
6610 }
6611 if !self.right_key.is_empty() {
6612 struct_ser.serialize_field("rightKey", &self.right_key)?;
6613 }
6614 if self.direction != 0 {
6615 let v = super::common::Direction::try_from(self.direction)
6616 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
6617 struct_ser.serialize_field("direction", &v)?;
6618 }
6619 if !self.output_indices.is_empty() {
6620 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6621 }
6622 struct_ser.end()
6623 }
6624}
6625impl<'de> serde::Deserialize<'de> for SortMergeJoinNode {
6626 #[allow(deprecated)]
6627 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6628 where
6629 D: serde::Deserializer<'de>,
6630 {
6631 const FIELDS: &[&str] = &[
6632 "join_type",
6633 "joinType",
6634 "left_key",
6635 "leftKey",
6636 "right_key",
6637 "rightKey",
6638 "direction",
6639 "output_indices",
6640 "outputIndices",
6641 ];
6642
6643 #[allow(clippy::enum_variant_names)]
6644 enum GeneratedField {
6645 JoinType,
6646 LeftKey,
6647 RightKey,
6648 Direction,
6649 OutputIndices,
6650 }
6651 impl<'de> serde::Deserialize<'de> for GeneratedField {
6652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6653 where
6654 D: serde::Deserializer<'de>,
6655 {
6656 struct GeneratedVisitor;
6657
6658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6659 type Value = GeneratedField;
6660
6661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6662 write!(formatter, "expected one of: {:?}", &FIELDS)
6663 }
6664
6665 #[allow(unused_variables)]
6666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6667 where
6668 E: serde::de::Error,
6669 {
6670 match value {
6671 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6672 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6673 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6674 "direction" => Ok(GeneratedField::Direction),
6675 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6676 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6677 }
6678 }
6679 }
6680 deserializer.deserialize_identifier(GeneratedVisitor)
6681 }
6682 }
6683 struct GeneratedVisitor;
6684 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6685 type Value = SortMergeJoinNode;
6686
6687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6688 formatter.write_str("struct batch_plan.SortMergeJoinNode")
6689 }
6690
6691 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortMergeJoinNode, V::Error>
6692 where
6693 V: serde::de::MapAccess<'de>,
6694 {
6695 let mut join_type__ = None;
6696 let mut left_key__ = None;
6697 let mut right_key__ = None;
6698 let mut direction__ = None;
6699 let mut output_indices__ = None;
6700 while let Some(k) = map_.next_key()? {
6701 match k {
6702 GeneratedField::JoinType => {
6703 if join_type__.is_some() {
6704 return Err(serde::de::Error::duplicate_field("joinType"));
6705 }
6706 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6707 }
6708 GeneratedField::LeftKey => {
6709 if left_key__.is_some() {
6710 return Err(serde::de::Error::duplicate_field("leftKey"));
6711 }
6712 left_key__ =
6713 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6714 .into_iter().map(|x| x.0).collect())
6715 ;
6716 }
6717 GeneratedField::RightKey => {
6718 if right_key__.is_some() {
6719 return Err(serde::de::Error::duplicate_field("rightKey"));
6720 }
6721 right_key__ =
6722 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6723 .into_iter().map(|x| x.0).collect())
6724 ;
6725 }
6726 GeneratedField::Direction => {
6727 if direction__.is_some() {
6728 return Err(serde::de::Error::duplicate_field("direction"));
6729 }
6730 direction__ = Some(map_.next_value::<super::common::Direction>()? as i32);
6731 }
6732 GeneratedField::OutputIndices => {
6733 if output_indices__.is_some() {
6734 return Err(serde::de::Error::duplicate_field("outputIndices"));
6735 }
6736 output_indices__ =
6737 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6738 .into_iter().map(|x| x.0).collect())
6739 ;
6740 }
6741 }
6742 }
6743 Ok(SortMergeJoinNode {
6744 join_type: join_type__.unwrap_or_default(),
6745 left_key: left_key__.unwrap_or_default(),
6746 right_key: right_key__.unwrap_or_default(),
6747 direction: direction__.unwrap_or_default(),
6748 output_indices: output_indices__.unwrap_or_default(),
6749 })
6750 }
6751 }
6752 deserializer.deserialize_struct("batch_plan.SortMergeJoinNode", FIELDS, GeneratedVisitor)
6753 }
6754}
6755impl serde::Serialize for SortNode {
6756 #[allow(deprecated)]
6757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6758 where
6759 S: serde::Serializer,
6760 {
6761 use serde::ser::SerializeStruct;
6762 let mut len = 0;
6763 if !self.column_orders.is_empty() {
6764 len += 1;
6765 }
6766 let mut struct_ser = serializer.serialize_struct("batch_plan.SortNode", len)?;
6767 if !self.column_orders.is_empty() {
6768 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6769 }
6770 struct_ser.end()
6771 }
6772}
6773impl<'de> serde::Deserialize<'de> for SortNode {
6774 #[allow(deprecated)]
6775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6776 where
6777 D: serde::Deserializer<'de>,
6778 {
6779 const FIELDS: &[&str] = &[
6780 "column_orders",
6781 "columnOrders",
6782 ];
6783
6784 #[allow(clippy::enum_variant_names)]
6785 enum GeneratedField {
6786 ColumnOrders,
6787 }
6788 impl<'de> serde::Deserialize<'de> for GeneratedField {
6789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6790 where
6791 D: serde::Deserializer<'de>,
6792 {
6793 struct GeneratedVisitor;
6794
6795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6796 type Value = GeneratedField;
6797
6798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6799 write!(formatter, "expected one of: {:?}", &FIELDS)
6800 }
6801
6802 #[allow(unused_variables)]
6803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6804 where
6805 E: serde::de::Error,
6806 {
6807 match value {
6808 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6810 }
6811 }
6812 }
6813 deserializer.deserialize_identifier(GeneratedVisitor)
6814 }
6815 }
6816 struct GeneratedVisitor;
6817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6818 type Value = SortNode;
6819
6820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6821 formatter.write_str("struct batch_plan.SortNode")
6822 }
6823
6824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
6825 where
6826 V: serde::de::MapAccess<'de>,
6827 {
6828 let mut column_orders__ = None;
6829 while let Some(k) = map_.next_key()? {
6830 match k {
6831 GeneratedField::ColumnOrders => {
6832 if column_orders__.is_some() {
6833 return Err(serde::de::Error::duplicate_field("columnOrders"));
6834 }
6835 column_orders__ = Some(map_.next_value()?);
6836 }
6837 }
6838 }
6839 Ok(SortNode {
6840 column_orders: column_orders__.unwrap_or_default(),
6841 })
6842 }
6843 }
6844 deserializer.deserialize_struct("batch_plan.SortNode", FIELDS, GeneratedVisitor)
6845 }
6846}
6847impl serde::Serialize for SortOverWindowNode {
6848 #[allow(deprecated)]
6849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6850 where
6851 S: serde::Serializer,
6852 {
6853 use serde::ser::SerializeStruct;
6854 let mut len = 0;
6855 if !self.calls.is_empty() {
6856 len += 1;
6857 }
6858 if !self.partition_by.is_empty() {
6859 len += 1;
6860 }
6861 if !self.order_by.is_empty() {
6862 len += 1;
6863 }
6864 let mut struct_ser = serializer.serialize_struct("batch_plan.SortOverWindowNode", len)?;
6865 if !self.calls.is_empty() {
6866 struct_ser.serialize_field("calls", &self.calls)?;
6867 }
6868 if !self.partition_by.is_empty() {
6869 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
6870 }
6871 if !self.order_by.is_empty() {
6872 struct_ser.serialize_field("orderBy", &self.order_by)?;
6873 }
6874 struct_ser.end()
6875 }
6876}
6877impl<'de> serde::Deserialize<'de> for SortOverWindowNode {
6878 #[allow(deprecated)]
6879 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6880 where
6881 D: serde::Deserializer<'de>,
6882 {
6883 const FIELDS: &[&str] = &[
6884 "calls",
6885 "partition_by",
6886 "partitionBy",
6887 "order_by",
6888 "orderBy",
6889 ];
6890
6891 #[allow(clippy::enum_variant_names)]
6892 enum GeneratedField {
6893 Calls,
6894 PartitionBy,
6895 OrderBy,
6896 }
6897 impl<'de> serde::Deserialize<'de> for GeneratedField {
6898 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6899 where
6900 D: serde::Deserializer<'de>,
6901 {
6902 struct GeneratedVisitor;
6903
6904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6905 type Value = GeneratedField;
6906
6907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6908 write!(formatter, "expected one of: {:?}", &FIELDS)
6909 }
6910
6911 #[allow(unused_variables)]
6912 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6913 where
6914 E: serde::de::Error,
6915 {
6916 match value {
6917 "calls" => Ok(GeneratedField::Calls),
6918 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
6919 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
6920 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6921 }
6922 }
6923 }
6924 deserializer.deserialize_identifier(GeneratedVisitor)
6925 }
6926 }
6927 struct GeneratedVisitor;
6928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6929 type Value = SortOverWindowNode;
6930
6931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6932 formatter.write_str("struct batch_plan.SortOverWindowNode")
6933 }
6934
6935 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortOverWindowNode, V::Error>
6936 where
6937 V: serde::de::MapAccess<'de>,
6938 {
6939 let mut calls__ = None;
6940 let mut partition_by__ = None;
6941 let mut order_by__ = None;
6942 while let Some(k) = map_.next_key()? {
6943 match k {
6944 GeneratedField::Calls => {
6945 if calls__.is_some() {
6946 return Err(serde::de::Error::duplicate_field("calls"));
6947 }
6948 calls__ = Some(map_.next_value()?);
6949 }
6950 GeneratedField::PartitionBy => {
6951 if partition_by__.is_some() {
6952 return Err(serde::de::Error::duplicate_field("partitionBy"));
6953 }
6954 partition_by__ =
6955 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6956 .into_iter().map(|x| x.0).collect())
6957 ;
6958 }
6959 GeneratedField::OrderBy => {
6960 if order_by__.is_some() {
6961 return Err(serde::de::Error::duplicate_field("orderBy"));
6962 }
6963 order_by__ = Some(map_.next_value()?);
6964 }
6965 }
6966 }
6967 Ok(SortOverWindowNode {
6968 calls: calls__.unwrap_or_default(),
6969 partition_by: partition_by__.unwrap_or_default(),
6970 order_by: order_by__.unwrap_or_default(),
6971 })
6972 }
6973 }
6974 deserializer.deserialize_struct("batch_plan.SortOverWindowNode", FIELDS, GeneratedVisitor)
6975 }
6976}
6977impl serde::Serialize for SourceNode {
6978 #[allow(deprecated)]
6979 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6980 where
6981 S: serde::Serializer,
6982 {
6983 use serde::ser::SerializeStruct;
6984 let mut len = 0;
6985 if self.source_id != 0 {
6986 len += 1;
6987 }
6988 if !self.columns.is_empty() {
6989 len += 1;
6990 }
6991 if !self.with_properties.is_empty() {
6992 len += 1;
6993 }
6994 if !self.split.is_empty() {
6995 len += 1;
6996 }
6997 if self.info.is_some() {
6998 len += 1;
6999 }
7000 if !self.secret_refs.is_empty() {
7001 len += 1;
7002 }
7003 let mut struct_ser = serializer.serialize_struct("batch_plan.SourceNode", len)?;
7004 if self.source_id != 0 {
7005 struct_ser.serialize_field("sourceId", &self.source_id)?;
7006 }
7007 if !self.columns.is_empty() {
7008 struct_ser.serialize_field("columns", &self.columns)?;
7009 }
7010 if !self.with_properties.is_empty() {
7011 struct_ser.serialize_field("withProperties", &self.with_properties)?;
7012 }
7013 if !self.split.is_empty() {
7014 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
7015 }
7016 if let Some(v) = self.info.as_ref() {
7017 struct_ser.serialize_field("info", v)?;
7018 }
7019 if !self.secret_refs.is_empty() {
7020 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
7021 }
7022 struct_ser.end()
7023 }
7024}
7025impl<'de> serde::Deserialize<'de> for SourceNode {
7026 #[allow(deprecated)]
7027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7028 where
7029 D: serde::Deserializer<'de>,
7030 {
7031 const FIELDS: &[&str] = &[
7032 "source_id",
7033 "sourceId",
7034 "columns",
7035 "with_properties",
7036 "withProperties",
7037 "split",
7038 "info",
7039 "secret_refs",
7040 "secretRefs",
7041 ];
7042
7043 #[allow(clippy::enum_variant_names)]
7044 enum GeneratedField {
7045 SourceId,
7046 Columns,
7047 WithProperties,
7048 Split,
7049 Info,
7050 SecretRefs,
7051 }
7052 impl<'de> serde::Deserialize<'de> for GeneratedField {
7053 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7054 where
7055 D: serde::Deserializer<'de>,
7056 {
7057 struct GeneratedVisitor;
7058
7059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7060 type Value = GeneratedField;
7061
7062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7063 write!(formatter, "expected one of: {:?}", &FIELDS)
7064 }
7065
7066 #[allow(unused_variables)]
7067 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7068 where
7069 E: serde::de::Error,
7070 {
7071 match value {
7072 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7073 "columns" => Ok(GeneratedField::Columns),
7074 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
7075 "split" => Ok(GeneratedField::Split),
7076 "info" => Ok(GeneratedField::Info),
7077 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
7078 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7079 }
7080 }
7081 }
7082 deserializer.deserialize_identifier(GeneratedVisitor)
7083 }
7084 }
7085 struct GeneratedVisitor;
7086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7087 type Value = SourceNode;
7088
7089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7090 formatter.write_str("struct batch_plan.SourceNode")
7091 }
7092
7093 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
7094 where
7095 V: serde::de::MapAccess<'de>,
7096 {
7097 let mut source_id__ = None;
7098 let mut columns__ = None;
7099 let mut with_properties__ = None;
7100 let mut split__ = None;
7101 let mut info__ = None;
7102 let mut secret_refs__ = None;
7103 while let Some(k) = map_.next_key()? {
7104 match k {
7105 GeneratedField::SourceId => {
7106 if source_id__.is_some() {
7107 return Err(serde::de::Error::duplicate_field("sourceId"));
7108 }
7109 source_id__ =
7110 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7111 ;
7112 }
7113 GeneratedField::Columns => {
7114 if columns__.is_some() {
7115 return Err(serde::de::Error::duplicate_field("columns"));
7116 }
7117 columns__ = Some(map_.next_value()?);
7118 }
7119 GeneratedField::WithProperties => {
7120 if with_properties__.is_some() {
7121 return Err(serde::de::Error::duplicate_field("withProperties"));
7122 }
7123 with_properties__ = Some(
7124 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7125 );
7126 }
7127 GeneratedField::Split => {
7128 if split__.is_some() {
7129 return Err(serde::de::Error::duplicate_field("split"));
7130 }
7131 split__ =
7132 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7133 .into_iter().map(|x| x.0).collect())
7134 ;
7135 }
7136 GeneratedField::Info => {
7137 if info__.is_some() {
7138 return Err(serde::de::Error::duplicate_field("info"));
7139 }
7140 info__ = map_.next_value()?;
7141 }
7142 GeneratedField::SecretRefs => {
7143 if secret_refs__.is_some() {
7144 return Err(serde::de::Error::duplicate_field("secretRefs"));
7145 }
7146 secret_refs__ = Some(
7147 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7148 );
7149 }
7150 }
7151 }
7152 Ok(SourceNode {
7153 source_id: source_id__.unwrap_or_default(),
7154 columns: columns__.unwrap_or_default(),
7155 with_properties: with_properties__.unwrap_or_default(),
7156 split: split__.unwrap_or_default(),
7157 info: info__,
7158 secret_refs: secret_refs__.unwrap_or_default(),
7159 })
7160 }
7161 }
7162 deserializer.deserialize_struct("batch_plan.SourceNode", FIELDS, GeneratedVisitor)
7163 }
7164}
7165impl serde::Serialize for SysRowSeqScanNode {
7166 #[allow(deprecated)]
7167 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7168 where
7169 S: serde::Serializer,
7170 {
7171 use serde::ser::SerializeStruct;
7172 let mut len = 0;
7173 if self.table_id != 0 {
7174 len += 1;
7175 }
7176 if !self.column_descs.is_empty() {
7177 len += 1;
7178 }
7179 let mut struct_ser = serializer.serialize_struct("batch_plan.SysRowSeqScanNode", len)?;
7180 if self.table_id != 0 {
7181 struct_ser.serialize_field("tableId", &self.table_id)?;
7182 }
7183 if !self.column_descs.is_empty() {
7184 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
7185 }
7186 struct_ser.end()
7187 }
7188}
7189impl<'de> serde::Deserialize<'de> for SysRowSeqScanNode {
7190 #[allow(deprecated)]
7191 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7192 where
7193 D: serde::Deserializer<'de>,
7194 {
7195 const FIELDS: &[&str] = &[
7196 "table_id",
7197 "tableId",
7198 "column_descs",
7199 "columnDescs",
7200 ];
7201
7202 #[allow(clippy::enum_variant_names)]
7203 enum GeneratedField {
7204 TableId,
7205 ColumnDescs,
7206 }
7207 impl<'de> serde::Deserialize<'de> for GeneratedField {
7208 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7209 where
7210 D: serde::Deserializer<'de>,
7211 {
7212 struct GeneratedVisitor;
7213
7214 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7215 type Value = GeneratedField;
7216
7217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7218 write!(formatter, "expected one of: {:?}", &FIELDS)
7219 }
7220
7221 #[allow(unused_variables)]
7222 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7223 where
7224 E: serde::de::Error,
7225 {
7226 match value {
7227 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7228 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
7229 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7230 }
7231 }
7232 }
7233 deserializer.deserialize_identifier(GeneratedVisitor)
7234 }
7235 }
7236 struct GeneratedVisitor;
7237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7238 type Value = SysRowSeqScanNode;
7239
7240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7241 formatter.write_str("struct batch_plan.SysRowSeqScanNode")
7242 }
7243
7244 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SysRowSeqScanNode, V::Error>
7245 where
7246 V: serde::de::MapAccess<'de>,
7247 {
7248 let mut table_id__ = None;
7249 let mut column_descs__ = None;
7250 while let Some(k) = map_.next_key()? {
7251 match k {
7252 GeneratedField::TableId => {
7253 if table_id__.is_some() {
7254 return Err(serde::de::Error::duplicate_field("tableId"));
7255 }
7256 table_id__ =
7257 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7258 ;
7259 }
7260 GeneratedField::ColumnDescs => {
7261 if column_descs__.is_some() {
7262 return Err(serde::de::Error::duplicate_field("columnDescs"));
7263 }
7264 column_descs__ = Some(map_.next_value()?);
7265 }
7266 }
7267 }
7268 Ok(SysRowSeqScanNode {
7269 table_id: table_id__.unwrap_or_default(),
7270 column_descs: column_descs__.unwrap_or_default(),
7271 })
7272 }
7273 }
7274 deserializer.deserialize_struct("batch_plan.SysRowSeqScanNode", FIELDS, GeneratedVisitor)
7275 }
7276}
7277impl serde::Serialize for TableFunctionNode {
7278 #[allow(deprecated)]
7279 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7280 where
7281 S: serde::Serializer,
7282 {
7283 use serde::ser::SerializeStruct;
7284 let mut len = 0;
7285 if self.table_function.is_some() {
7286 len += 1;
7287 }
7288 let mut struct_ser = serializer.serialize_struct("batch_plan.TableFunctionNode", len)?;
7289 if let Some(v) = self.table_function.as_ref() {
7290 struct_ser.serialize_field("tableFunction", v)?;
7291 }
7292 struct_ser.end()
7293 }
7294}
7295impl<'de> serde::Deserialize<'de> for TableFunctionNode {
7296 #[allow(deprecated)]
7297 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7298 where
7299 D: serde::Deserializer<'de>,
7300 {
7301 const FIELDS: &[&str] = &[
7302 "table_function",
7303 "tableFunction",
7304 ];
7305
7306 #[allow(clippy::enum_variant_names)]
7307 enum GeneratedField {
7308 TableFunction,
7309 }
7310 impl<'de> serde::Deserialize<'de> for GeneratedField {
7311 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7312 where
7313 D: serde::Deserializer<'de>,
7314 {
7315 struct GeneratedVisitor;
7316
7317 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7318 type Value = GeneratedField;
7319
7320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7321 write!(formatter, "expected one of: {:?}", &FIELDS)
7322 }
7323
7324 #[allow(unused_variables)]
7325 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7326 where
7327 E: serde::de::Error,
7328 {
7329 match value {
7330 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
7331 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7332 }
7333 }
7334 }
7335 deserializer.deserialize_identifier(GeneratedVisitor)
7336 }
7337 }
7338 struct GeneratedVisitor;
7339 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7340 type Value = TableFunctionNode;
7341
7342 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7343 formatter.write_str("struct batch_plan.TableFunctionNode")
7344 }
7345
7346 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunctionNode, V::Error>
7347 where
7348 V: serde::de::MapAccess<'de>,
7349 {
7350 let mut table_function__ = None;
7351 while let Some(k) = map_.next_key()? {
7352 match k {
7353 GeneratedField::TableFunction => {
7354 if table_function__.is_some() {
7355 return Err(serde::de::Error::duplicate_field("tableFunction"));
7356 }
7357 table_function__ = map_.next_value()?;
7358 }
7359 }
7360 }
7361 Ok(TableFunctionNode {
7362 table_function: table_function__,
7363 })
7364 }
7365 }
7366 deserializer.deserialize_struct("batch_plan.TableFunctionNode", FIELDS, GeneratedVisitor)
7367 }
7368}
7369impl serde::Serialize for TaskId {
7370 #[allow(deprecated)]
7371 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7372 where
7373 S: serde::Serializer,
7374 {
7375 use serde::ser::SerializeStruct;
7376 let mut len = 0;
7377 if !self.query_id.is_empty() {
7378 len += 1;
7379 }
7380 if self.stage_id != 0 {
7381 len += 1;
7382 }
7383 if self.task_id != 0 {
7384 len += 1;
7385 }
7386 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskId", len)?;
7387 if !self.query_id.is_empty() {
7388 struct_ser.serialize_field("queryId", &self.query_id)?;
7389 }
7390 if self.stage_id != 0 {
7391 struct_ser.serialize_field("stageId", &self.stage_id)?;
7392 }
7393 if self.task_id != 0 {
7394 #[allow(clippy::needless_borrow)]
7395 #[allow(clippy::needless_borrows_for_generic_args)]
7396 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7397 }
7398 struct_ser.end()
7399 }
7400}
7401impl<'de> serde::Deserialize<'de> for TaskId {
7402 #[allow(deprecated)]
7403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7404 where
7405 D: serde::Deserializer<'de>,
7406 {
7407 const FIELDS: &[&str] = &[
7408 "query_id",
7409 "queryId",
7410 "stage_id",
7411 "stageId",
7412 "task_id",
7413 "taskId",
7414 ];
7415
7416 #[allow(clippy::enum_variant_names)]
7417 enum GeneratedField {
7418 QueryId,
7419 StageId,
7420 TaskId,
7421 }
7422 impl<'de> serde::Deserialize<'de> for GeneratedField {
7423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7424 where
7425 D: serde::Deserializer<'de>,
7426 {
7427 struct GeneratedVisitor;
7428
7429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7430 type Value = GeneratedField;
7431
7432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7433 write!(formatter, "expected one of: {:?}", &FIELDS)
7434 }
7435
7436 #[allow(unused_variables)]
7437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7438 where
7439 E: serde::de::Error,
7440 {
7441 match value {
7442 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
7443 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
7444 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7445 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7446 }
7447 }
7448 }
7449 deserializer.deserialize_identifier(GeneratedVisitor)
7450 }
7451 }
7452 struct GeneratedVisitor;
7453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7454 type Value = TaskId;
7455
7456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7457 formatter.write_str("struct batch_plan.TaskId")
7458 }
7459
7460 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
7461 where
7462 V: serde::de::MapAccess<'de>,
7463 {
7464 let mut query_id__ = None;
7465 let mut stage_id__ = None;
7466 let mut task_id__ = None;
7467 while let Some(k) = map_.next_key()? {
7468 match k {
7469 GeneratedField::QueryId => {
7470 if query_id__.is_some() {
7471 return Err(serde::de::Error::duplicate_field("queryId"));
7472 }
7473 query_id__ = Some(map_.next_value()?);
7474 }
7475 GeneratedField::StageId => {
7476 if stage_id__.is_some() {
7477 return Err(serde::de::Error::duplicate_field("stageId"));
7478 }
7479 stage_id__ =
7480 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7481 ;
7482 }
7483 GeneratedField::TaskId => {
7484 if task_id__.is_some() {
7485 return Err(serde::de::Error::duplicate_field("taskId"));
7486 }
7487 task_id__ =
7488 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7489 ;
7490 }
7491 }
7492 }
7493 Ok(TaskId {
7494 query_id: query_id__.unwrap_or_default(),
7495 stage_id: stage_id__.unwrap_or_default(),
7496 task_id: task_id__.unwrap_or_default(),
7497 })
7498 }
7499 }
7500 deserializer.deserialize_struct("batch_plan.TaskId", FIELDS, GeneratedVisitor)
7501 }
7502}
7503impl serde::Serialize for TaskOutputId {
7504 #[allow(deprecated)]
7505 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7506 where
7507 S: serde::Serializer,
7508 {
7509 use serde::ser::SerializeStruct;
7510 let mut len = 0;
7511 if self.task_id.is_some() {
7512 len += 1;
7513 }
7514 if self.output_id != 0 {
7515 len += 1;
7516 }
7517 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskOutputId", len)?;
7518 if let Some(v) = self.task_id.as_ref() {
7519 struct_ser.serialize_field("taskId", v)?;
7520 }
7521 if self.output_id != 0 {
7522 #[allow(clippy::needless_borrow)]
7523 #[allow(clippy::needless_borrows_for_generic_args)]
7524 struct_ser.serialize_field("outputId", ToString::to_string(&self.output_id).as_str())?;
7525 }
7526 struct_ser.end()
7527 }
7528}
7529impl<'de> serde::Deserialize<'de> for TaskOutputId {
7530 #[allow(deprecated)]
7531 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7532 where
7533 D: serde::Deserializer<'de>,
7534 {
7535 const FIELDS: &[&str] = &[
7536 "task_id",
7537 "taskId",
7538 "output_id",
7539 "outputId",
7540 ];
7541
7542 #[allow(clippy::enum_variant_names)]
7543 enum GeneratedField {
7544 TaskId,
7545 OutputId,
7546 }
7547 impl<'de> serde::Deserialize<'de> for GeneratedField {
7548 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7549 where
7550 D: serde::Deserializer<'de>,
7551 {
7552 struct GeneratedVisitor;
7553
7554 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7555 type Value = GeneratedField;
7556
7557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7558 write!(formatter, "expected one of: {:?}", &FIELDS)
7559 }
7560
7561 #[allow(unused_variables)]
7562 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7563 where
7564 E: serde::de::Error,
7565 {
7566 match value {
7567 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7568 "outputId" | "output_id" => Ok(GeneratedField::OutputId),
7569 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7570 }
7571 }
7572 }
7573 deserializer.deserialize_identifier(GeneratedVisitor)
7574 }
7575 }
7576 struct GeneratedVisitor;
7577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7578 type Value = TaskOutputId;
7579
7580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7581 formatter.write_str("struct batch_plan.TaskOutputId")
7582 }
7583
7584 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskOutputId, V::Error>
7585 where
7586 V: serde::de::MapAccess<'de>,
7587 {
7588 let mut task_id__ = None;
7589 let mut output_id__ = None;
7590 while let Some(k) = map_.next_key()? {
7591 match k {
7592 GeneratedField::TaskId => {
7593 if task_id__.is_some() {
7594 return Err(serde::de::Error::duplicate_field("taskId"));
7595 }
7596 task_id__ = map_.next_value()?;
7597 }
7598 GeneratedField::OutputId => {
7599 if output_id__.is_some() {
7600 return Err(serde::de::Error::duplicate_field("outputId"));
7601 }
7602 output_id__ =
7603 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7604 ;
7605 }
7606 }
7607 }
7608 Ok(TaskOutputId {
7609 task_id: task_id__,
7610 output_id: output_id__.unwrap_or_default(),
7611 })
7612 }
7613 }
7614 deserializer.deserialize_struct("batch_plan.TaskOutputId", FIELDS, GeneratedVisitor)
7615 }
7616}
7617impl serde::Serialize for TopNNode {
7618 #[allow(deprecated)]
7619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7620 where
7621 S: serde::Serializer,
7622 {
7623 use serde::ser::SerializeStruct;
7624 let mut len = 0;
7625 if !self.column_orders.is_empty() {
7626 len += 1;
7627 }
7628 if self.limit != 0 {
7629 len += 1;
7630 }
7631 if self.offset != 0 {
7632 len += 1;
7633 }
7634 if self.with_ties {
7635 len += 1;
7636 }
7637 let mut struct_ser = serializer.serialize_struct("batch_plan.TopNNode", len)?;
7638 if !self.column_orders.is_empty() {
7639 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7640 }
7641 if self.limit != 0 {
7642 #[allow(clippy::needless_borrow)]
7643 #[allow(clippy::needless_borrows_for_generic_args)]
7644 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
7645 }
7646 if self.offset != 0 {
7647 #[allow(clippy::needless_borrow)]
7648 #[allow(clippy::needless_borrows_for_generic_args)]
7649 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
7650 }
7651 if self.with_ties {
7652 struct_ser.serialize_field("withTies", &self.with_ties)?;
7653 }
7654 struct_ser.end()
7655 }
7656}
7657impl<'de> serde::Deserialize<'de> for TopNNode {
7658 #[allow(deprecated)]
7659 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7660 where
7661 D: serde::Deserializer<'de>,
7662 {
7663 const FIELDS: &[&str] = &[
7664 "column_orders",
7665 "columnOrders",
7666 "limit",
7667 "offset",
7668 "with_ties",
7669 "withTies",
7670 ];
7671
7672 #[allow(clippy::enum_variant_names)]
7673 enum GeneratedField {
7674 ColumnOrders,
7675 Limit,
7676 Offset,
7677 WithTies,
7678 }
7679 impl<'de> serde::Deserialize<'de> for GeneratedField {
7680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7681 where
7682 D: serde::Deserializer<'de>,
7683 {
7684 struct GeneratedVisitor;
7685
7686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7687 type Value = GeneratedField;
7688
7689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7690 write!(formatter, "expected one of: {:?}", &FIELDS)
7691 }
7692
7693 #[allow(unused_variables)]
7694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7695 where
7696 E: serde::de::Error,
7697 {
7698 match value {
7699 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7700 "limit" => Ok(GeneratedField::Limit),
7701 "offset" => Ok(GeneratedField::Offset),
7702 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
7703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7704 }
7705 }
7706 }
7707 deserializer.deserialize_identifier(GeneratedVisitor)
7708 }
7709 }
7710 struct GeneratedVisitor;
7711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7712 type Value = TopNNode;
7713
7714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7715 formatter.write_str("struct batch_plan.TopNNode")
7716 }
7717
7718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
7719 where
7720 V: serde::de::MapAccess<'de>,
7721 {
7722 let mut column_orders__ = None;
7723 let mut limit__ = None;
7724 let mut offset__ = None;
7725 let mut with_ties__ = None;
7726 while let Some(k) = map_.next_key()? {
7727 match k {
7728 GeneratedField::ColumnOrders => {
7729 if column_orders__.is_some() {
7730 return Err(serde::de::Error::duplicate_field("columnOrders"));
7731 }
7732 column_orders__ = Some(map_.next_value()?);
7733 }
7734 GeneratedField::Limit => {
7735 if limit__.is_some() {
7736 return Err(serde::de::Error::duplicate_field("limit"));
7737 }
7738 limit__ =
7739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7740 ;
7741 }
7742 GeneratedField::Offset => {
7743 if offset__.is_some() {
7744 return Err(serde::de::Error::duplicate_field("offset"));
7745 }
7746 offset__ =
7747 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7748 ;
7749 }
7750 GeneratedField::WithTies => {
7751 if with_ties__.is_some() {
7752 return Err(serde::de::Error::duplicate_field("withTies"));
7753 }
7754 with_ties__ = Some(map_.next_value()?);
7755 }
7756 }
7757 }
7758 Ok(TopNNode {
7759 column_orders: column_orders__.unwrap_or_default(),
7760 limit: limit__.unwrap_or_default(),
7761 offset: offset__.unwrap_or_default(),
7762 with_ties: with_ties__.unwrap_or_default(),
7763 })
7764 }
7765 }
7766 deserializer.deserialize_struct("batch_plan.TopNNode", FIELDS, GeneratedVisitor)
7767 }
7768}
7769impl serde::Serialize for UnionNode {
7770 #[allow(deprecated)]
7771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7772 where
7773 S: serde::Serializer,
7774 {
7775 use serde::ser::SerializeStruct;
7776 let len = 0;
7777 let struct_ser = serializer.serialize_struct("batch_plan.UnionNode", len)?;
7778 struct_ser.end()
7779 }
7780}
7781impl<'de> serde::Deserialize<'de> for UnionNode {
7782 #[allow(deprecated)]
7783 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7784 where
7785 D: serde::Deserializer<'de>,
7786 {
7787 const FIELDS: &[&str] = &[
7788 ];
7789
7790 #[allow(clippy::enum_variant_names)]
7791 enum GeneratedField {
7792 }
7793 impl<'de> serde::Deserialize<'de> for GeneratedField {
7794 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7795 where
7796 D: serde::Deserializer<'de>,
7797 {
7798 struct GeneratedVisitor;
7799
7800 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7801 type Value = GeneratedField;
7802
7803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7804 write!(formatter, "expected one of: {:?}", &FIELDS)
7805 }
7806
7807 #[allow(unused_variables)]
7808 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7809 where
7810 E: serde::de::Error,
7811 {
7812 Err(serde::de::Error::unknown_field(value, FIELDS))
7813 }
7814 }
7815 deserializer.deserialize_identifier(GeneratedVisitor)
7816 }
7817 }
7818 struct GeneratedVisitor;
7819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7820 type Value = UnionNode;
7821
7822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7823 formatter.write_str("struct batch_plan.UnionNode")
7824 }
7825
7826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
7827 where
7828 V: serde::de::MapAccess<'de>,
7829 {
7830 while map_.next_key::<GeneratedField>()?.is_some() {
7831 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7832 }
7833 Ok(UnionNode {
7834 })
7835 }
7836 }
7837 deserializer.deserialize_struct("batch_plan.UnionNode", FIELDS, GeneratedVisitor)
7838 }
7839}
7840impl serde::Serialize for UpdateNode {
7841 #[allow(deprecated)]
7842 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7843 where
7844 S: serde::Serializer,
7845 {
7846 use serde::ser::SerializeStruct;
7847 let mut len = 0;
7848 if self.table_id != 0 {
7849 len += 1;
7850 }
7851 if self.table_version_id != 0 {
7852 len += 1;
7853 }
7854 if !self.old_exprs.is_empty() {
7855 len += 1;
7856 }
7857 if !self.new_exprs.is_empty() {
7858 len += 1;
7859 }
7860 if self.returning {
7861 len += 1;
7862 }
7863 if self.session_id != 0 {
7864 len += 1;
7865 }
7866 let mut struct_ser = serializer.serialize_struct("batch_plan.UpdateNode", len)?;
7867 if self.table_id != 0 {
7868 struct_ser.serialize_field("tableId", &self.table_id)?;
7869 }
7870 if self.table_version_id != 0 {
7871 #[allow(clippy::needless_borrow)]
7872 #[allow(clippy::needless_borrows_for_generic_args)]
7873 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
7874 }
7875 if !self.old_exprs.is_empty() {
7876 struct_ser.serialize_field("oldExprs", &self.old_exprs)?;
7877 }
7878 if !self.new_exprs.is_empty() {
7879 struct_ser.serialize_field("newExprs", &self.new_exprs)?;
7880 }
7881 if self.returning {
7882 struct_ser.serialize_field("returning", &self.returning)?;
7883 }
7884 if self.session_id != 0 {
7885 struct_ser.serialize_field("sessionId", &self.session_id)?;
7886 }
7887 struct_ser.end()
7888 }
7889}
7890impl<'de> serde::Deserialize<'de> for UpdateNode {
7891 #[allow(deprecated)]
7892 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7893 where
7894 D: serde::Deserializer<'de>,
7895 {
7896 const FIELDS: &[&str] = &[
7897 "table_id",
7898 "tableId",
7899 "table_version_id",
7900 "tableVersionId",
7901 "old_exprs",
7902 "oldExprs",
7903 "new_exprs",
7904 "newExprs",
7905 "returning",
7906 "session_id",
7907 "sessionId",
7908 ];
7909
7910 #[allow(clippy::enum_variant_names)]
7911 enum GeneratedField {
7912 TableId,
7913 TableVersionId,
7914 OldExprs,
7915 NewExprs,
7916 Returning,
7917 SessionId,
7918 }
7919 impl<'de> serde::Deserialize<'de> for GeneratedField {
7920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7921 where
7922 D: serde::Deserializer<'de>,
7923 {
7924 struct GeneratedVisitor;
7925
7926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7927 type Value = GeneratedField;
7928
7929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7930 write!(formatter, "expected one of: {:?}", &FIELDS)
7931 }
7932
7933 #[allow(unused_variables)]
7934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7935 where
7936 E: serde::de::Error,
7937 {
7938 match value {
7939 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7940 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
7941 "oldExprs" | "old_exprs" => Ok(GeneratedField::OldExprs),
7942 "newExprs" | "new_exprs" => Ok(GeneratedField::NewExprs),
7943 "returning" => Ok(GeneratedField::Returning),
7944 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
7945 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7946 }
7947 }
7948 }
7949 deserializer.deserialize_identifier(GeneratedVisitor)
7950 }
7951 }
7952 struct GeneratedVisitor;
7953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7954 type Value = UpdateNode;
7955
7956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7957 formatter.write_str("struct batch_plan.UpdateNode")
7958 }
7959
7960 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateNode, V::Error>
7961 where
7962 V: serde::de::MapAccess<'de>,
7963 {
7964 let mut table_id__ = None;
7965 let mut table_version_id__ = None;
7966 let mut old_exprs__ = None;
7967 let mut new_exprs__ = None;
7968 let mut returning__ = None;
7969 let mut session_id__ = None;
7970 while let Some(k) = map_.next_key()? {
7971 match k {
7972 GeneratedField::TableId => {
7973 if table_id__.is_some() {
7974 return Err(serde::de::Error::duplicate_field("tableId"));
7975 }
7976 table_id__ =
7977 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7978 ;
7979 }
7980 GeneratedField::TableVersionId => {
7981 if table_version_id__.is_some() {
7982 return Err(serde::de::Error::duplicate_field("tableVersionId"));
7983 }
7984 table_version_id__ =
7985 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7986 ;
7987 }
7988 GeneratedField::OldExprs => {
7989 if old_exprs__.is_some() {
7990 return Err(serde::de::Error::duplicate_field("oldExprs"));
7991 }
7992 old_exprs__ = Some(map_.next_value()?);
7993 }
7994 GeneratedField::NewExprs => {
7995 if new_exprs__.is_some() {
7996 return Err(serde::de::Error::duplicate_field("newExprs"));
7997 }
7998 new_exprs__ = Some(map_.next_value()?);
7999 }
8000 GeneratedField::Returning => {
8001 if returning__.is_some() {
8002 return Err(serde::de::Error::duplicate_field("returning"));
8003 }
8004 returning__ = Some(map_.next_value()?);
8005 }
8006 GeneratedField::SessionId => {
8007 if session_id__.is_some() {
8008 return Err(serde::de::Error::duplicate_field("sessionId"));
8009 }
8010 session_id__ =
8011 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8012 ;
8013 }
8014 }
8015 }
8016 Ok(UpdateNode {
8017 table_id: table_id__.unwrap_or_default(),
8018 table_version_id: table_version_id__.unwrap_or_default(),
8019 old_exprs: old_exprs__.unwrap_or_default(),
8020 new_exprs: new_exprs__.unwrap_or_default(),
8021 returning: returning__.unwrap_or_default(),
8022 session_id: session_id__.unwrap_or_default(),
8023 })
8024 }
8025 }
8026 deserializer.deserialize_struct("batch_plan.UpdateNode", FIELDS, GeneratedVisitor)
8027 }
8028}
8029impl serde::Serialize for ValuesNode {
8030 #[allow(deprecated)]
8031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8032 where
8033 S: serde::Serializer,
8034 {
8035 use serde::ser::SerializeStruct;
8036 let mut len = 0;
8037 if !self.tuples.is_empty() {
8038 len += 1;
8039 }
8040 if !self.fields.is_empty() {
8041 len += 1;
8042 }
8043 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode", len)?;
8044 if !self.tuples.is_empty() {
8045 struct_ser.serialize_field("tuples", &self.tuples)?;
8046 }
8047 if !self.fields.is_empty() {
8048 struct_ser.serialize_field("fields", &self.fields)?;
8049 }
8050 struct_ser.end()
8051 }
8052}
8053impl<'de> serde::Deserialize<'de> for ValuesNode {
8054 #[allow(deprecated)]
8055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8056 where
8057 D: serde::Deserializer<'de>,
8058 {
8059 const FIELDS: &[&str] = &[
8060 "tuples",
8061 "fields",
8062 ];
8063
8064 #[allow(clippy::enum_variant_names)]
8065 enum GeneratedField {
8066 Tuples,
8067 Fields,
8068 }
8069 impl<'de> serde::Deserialize<'de> for GeneratedField {
8070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8071 where
8072 D: serde::Deserializer<'de>,
8073 {
8074 struct GeneratedVisitor;
8075
8076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8077 type Value = GeneratedField;
8078
8079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8080 write!(formatter, "expected one of: {:?}", &FIELDS)
8081 }
8082
8083 #[allow(unused_variables)]
8084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8085 where
8086 E: serde::de::Error,
8087 {
8088 match value {
8089 "tuples" => Ok(GeneratedField::Tuples),
8090 "fields" => Ok(GeneratedField::Fields),
8091 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8092 }
8093 }
8094 }
8095 deserializer.deserialize_identifier(GeneratedVisitor)
8096 }
8097 }
8098 struct GeneratedVisitor;
8099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8100 type Value = ValuesNode;
8101
8102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8103 formatter.write_str("struct batch_plan.ValuesNode")
8104 }
8105
8106 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
8107 where
8108 V: serde::de::MapAccess<'de>,
8109 {
8110 let mut tuples__ = None;
8111 let mut fields__ = None;
8112 while let Some(k) = map_.next_key()? {
8113 match k {
8114 GeneratedField::Tuples => {
8115 if tuples__.is_some() {
8116 return Err(serde::de::Error::duplicate_field("tuples"));
8117 }
8118 tuples__ = Some(map_.next_value()?);
8119 }
8120 GeneratedField::Fields => {
8121 if fields__.is_some() {
8122 return Err(serde::de::Error::duplicate_field("fields"));
8123 }
8124 fields__ = Some(map_.next_value()?);
8125 }
8126 }
8127 }
8128 Ok(ValuesNode {
8129 tuples: tuples__.unwrap_or_default(),
8130 fields: fields__.unwrap_or_default(),
8131 })
8132 }
8133 }
8134 deserializer.deserialize_struct("batch_plan.ValuesNode", FIELDS, GeneratedVisitor)
8135 }
8136}
8137impl serde::Serialize for values_node::ExprTuple {
8138 #[allow(deprecated)]
8139 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8140 where
8141 S: serde::Serializer,
8142 {
8143 use serde::ser::SerializeStruct;
8144 let mut len = 0;
8145 if !self.cells.is_empty() {
8146 len += 1;
8147 }
8148 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode.ExprTuple", len)?;
8149 if !self.cells.is_empty() {
8150 struct_ser.serialize_field("cells", &self.cells)?;
8151 }
8152 struct_ser.end()
8153 }
8154}
8155impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
8156 #[allow(deprecated)]
8157 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8158 where
8159 D: serde::Deserializer<'de>,
8160 {
8161 const FIELDS: &[&str] = &[
8162 "cells",
8163 ];
8164
8165 #[allow(clippy::enum_variant_names)]
8166 enum GeneratedField {
8167 Cells,
8168 }
8169 impl<'de> serde::Deserialize<'de> for GeneratedField {
8170 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8171 where
8172 D: serde::Deserializer<'de>,
8173 {
8174 struct GeneratedVisitor;
8175
8176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8177 type Value = GeneratedField;
8178
8179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8180 write!(formatter, "expected one of: {:?}", &FIELDS)
8181 }
8182
8183 #[allow(unused_variables)]
8184 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8185 where
8186 E: serde::de::Error,
8187 {
8188 match value {
8189 "cells" => Ok(GeneratedField::Cells),
8190 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8191 }
8192 }
8193 }
8194 deserializer.deserialize_identifier(GeneratedVisitor)
8195 }
8196 }
8197 struct GeneratedVisitor;
8198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8199 type Value = values_node::ExprTuple;
8200
8201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8202 formatter.write_str("struct batch_plan.ValuesNode.ExprTuple")
8203 }
8204
8205 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
8206 where
8207 V: serde::de::MapAccess<'de>,
8208 {
8209 let mut cells__ = None;
8210 while let Some(k) = map_.next_key()? {
8211 match k {
8212 GeneratedField::Cells => {
8213 if cells__.is_some() {
8214 return Err(serde::de::Error::duplicate_field("cells"));
8215 }
8216 cells__ = Some(map_.next_value()?);
8217 }
8218 }
8219 }
8220 Ok(values_node::ExprTuple {
8221 cells: cells__.unwrap_or_default(),
8222 })
8223 }
8224 }
8225 deserializer.deserialize_struct("batch_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
8226 }
8227}
8228impl serde::Serialize for VectorIndexNearestNode {
8229 #[allow(deprecated)]
8230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8231 where
8232 S: serde::Serializer,
8233 {
8234 use serde::ser::SerializeStruct;
8235 let mut len = 0;
8236 if self.reader_desc.is_some() {
8237 len += 1;
8238 }
8239 if self.vector_column_idx != 0 {
8240 len += 1;
8241 }
8242 if self.query_epoch.is_some() {
8243 len += 1;
8244 }
8245 let mut struct_ser = serializer.serialize_struct("batch_plan.VectorIndexNearestNode", len)?;
8246 if let Some(v) = self.reader_desc.as_ref() {
8247 struct_ser.serialize_field("readerDesc", v)?;
8248 }
8249 if self.vector_column_idx != 0 {
8250 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
8251 }
8252 if let Some(v) = self.query_epoch.as_ref() {
8253 struct_ser.serialize_field("queryEpoch", v)?;
8254 }
8255 struct_ser.end()
8256 }
8257}
8258impl<'de> serde::Deserialize<'de> for VectorIndexNearestNode {
8259 #[allow(deprecated)]
8260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8261 where
8262 D: serde::Deserializer<'de>,
8263 {
8264 const FIELDS: &[&str] = &[
8265 "reader_desc",
8266 "readerDesc",
8267 "vector_column_idx",
8268 "vectorColumnIdx",
8269 "query_epoch",
8270 "queryEpoch",
8271 ];
8272
8273 #[allow(clippy::enum_variant_names)]
8274 enum GeneratedField {
8275 ReaderDesc,
8276 VectorColumnIdx,
8277 QueryEpoch,
8278 }
8279 impl<'de> serde::Deserialize<'de> for GeneratedField {
8280 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8281 where
8282 D: serde::Deserializer<'de>,
8283 {
8284 struct GeneratedVisitor;
8285
8286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8287 type Value = GeneratedField;
8288
8289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8290 write!(formatter, "expected one of: {:?}", &FIELDS)
8291 }
8292
8293 #[allow(unused_variables)]
8294 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8295 where
8296 E: serde::de::Error,
8297 {
8298 match value {
8299 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
8300 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
8301 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
8302 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8303 }
8304 }
8305 }
8306 deserializer.deserialize_identifier(GeneratedVisitor)
8307 }
8308 }
8309 struct GeneratedVisitor;
8310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8311 type Value = VectorIndexNearestNode;
8312
8313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8314 formatter.write_str("struct batch_plan.VectorIndexNearestNode")
8315 }
8316
8317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexNearestNode, V::Error>
8318 where
8319 V: serde::de::MapAccess<'de>,
8320 {
8321 let mut reader_desc__ = None;
8322 let mut vector_column_idx__ = None;
8323 let mut query_epoch__ = None;
8324 while let Some(k) = map_.next_key()? {
8325 match k {
8326 GeneratedField::ReaderDesc => {
8327 if reader_desc__.is_some() {
8328 return Err(serde::de::Error::duplicate_field("readerDesc"));
8329 }
8330 reader_desc__ = map_.next_value()?;
8331 }
8332 GeneratedField::VectorColumnIdx => {
8333 if vector_column_idx__.is_some() {
8334 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
8335 }
8336 vector_column_idx__ =
8337 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8338 ;
8339 }
8340 GeneratedField::QueryEpoch => {
8341 if query_epoch__.is_some() {
8342 return Err(serde::de::Error::duplicate_field("queryEpoch"));
8343 }
8344 query_epoch__ = map_.next_value()?;
8345 }
8346 }
8347 }
8348 Ok(VectorIndexNearestNode {
8349 reader_desc: reader_desc__,
8350 vector_column_idx: vector_column_idx__.unwrap_or_default(),
8351 query_epoch: query_epoch__,
8352 })
8353 }
8354 }
8355 deserializer.deserialize_struct("batch_plan.VectorIndexNearestNode", FIELDS, GeneratedVisitor)
8356 }
8357}