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