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