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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 serde::de::Visitor<'_> 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 if !self.ssl_mode.is_empty() {
5714 len += 1;
5715 }
5716 if !self.ssl_root_cert.is_empty() {
5717 len += 1;
5718 }
5719 let mut struct_ser = serializer.serialize_struct("batch_plan.PostgresQueryNode", len)?;
5720 if !self.columns.is_empty() {
5721 struct_ser.serialize_field("columns", &self.columns)?;
5722 }
5723 if !self.hostname.is_empty() {
5724 struct_ser.serialize_field("hostname", &self.hostname)?;
5725 }
5726 if !self.port.is_empty() {
5727 struct_ser.serialize_field("port", &self.port)?;
5728 }
5729 if !self.username.is_empty() {
5730 struct_ser.serialize_field("username", &self.username)?;
5731 }
5732 if !self.password.is_empty() {
5733 struct_ser.serialize_field("password", &self.password)?;
5734 }
5735 if !self.database.is_empty() {
5736 struct_ser.serialize_field("database", &self.database)?;
5737 }
5738 if !self.query.is_empty() {
5739 struct_ser.serialize_field("query", &self.query)?;
5740 }
5741 if !self.ssl_mode.is_empty() {
5742 struct_ser.serialize_field("sslMode", &self.ssl_mode)?;
5743 }
5744 if !self.ssl_root_cert.is_empty() {
5745 struct_ser.serialize_field("sslRootCert", &self.ssl_root_cert)?;
5746 }
5747 struct_ser.end()
5748 }
5749}
5750impl<'de> serde::Deserialize<'de> for PostgresQueryNode {
5751 #[allow(deprecated)]
5752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5753 where
5754 D: serde::Deserializer<'de>,
5755 {
5756 const FIELDS: &[&str] = &[
5757 "columns",
5758 "hostname",
5759 "port",
5760 "username",
5761 "password",
5762 "database",
5763 "query",
5764 "ssl_mode",
5765 "sslMode",
5766 "ssl_root_cert",
5767 "sslRootCert",
5768 ];
5769
5770 #[allow(clippy::enum_variant_names)]
5771 enum GeneratedField {
5772 Columns,
5773 Hostname,
5774 Port,
5775 Username,
5776 Password,
5777 Database,
5778 Query,
5779 SslMode,
5780 SslRootCert,
5781 }
5782 impl<'de> serde::Deserialize<'de> for GeneratedField {
5783 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5784 where
5785 D: serde::Deserializer<'de>,
5786 {
5787 struct GeneratedVisitor;
5788
5789 impl serde::de::Visitor<'_> for GeneratedVisitor {
5790 type Value = GeneratedField;
5791
5792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5793 write!(formatter, "expected one of: {:?}", &FIELDS)
5794 }
5795
5796 #[allow(unused_variables)]
5797 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5798 where
5799 E: serde::de::Error,
5800 {
5801 match value {
5802 "columns" => Ok(GeneratedField::Columns),
5803 "hostname" => Ok(GeneratedField::Hostname),
5804 "port" => Ok(GeneratedField::Port),
5805 "username" => Ok(GeneratedField::Username),
5806 "password" => Ok(GeneratedField::Password),
5807 "database" => Ok(GeneratedField::Database),
5808 "query" => Ok(GeneratedField::Query),
5809 "sslMode" | "ssl_mode" => Ok(GeneratedField::SslMode),
5810 "sslRootCert" | "ssl_root_cert" => Ok(GeneratedField::SslRootCert),
5811 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5812 }
5813 }
5814 }
5815 deserializer.deserialize_identifier(GeneratedVisitor)
5816 }
5817 }
5818 struct GeneratedVisitor;
5819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5820 type Value = PostgresQueryNode;
5821
5822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5823 formatter.write_str("struct batch_plan.PostgresQueryNode")
5824 }
5825
5826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PostgresQueryNode, V::Error>
5827 where
5828 V: serde::de::MapAccess<'de>,
5829 {
5830 let mut columns__ = None;
5831 let mut hostname__ = None;
5832 let mut port__ = None;
5833 let mut username__ = None;
5834 let mut password__ = None;
5835 let mut database__ = None;
5836 let mut query__ = None;
5837 let mut ssl_mode__ = None;
5838 let mut ssl_root_cert__ = None;
5839 while let Some(k) = map_.next_key()? {
5840 match k {
5841 GeneratedField::Columns => {
5842 if columns__.is_some() {
5843 return Err(serde::de::Error::duplicate_field("columns"));
5844 }
5845 columns__ = Some(map_.next_value()?);
5846 }
5847 GeneratedField::Hostname => {
5848 if hostname__.is_some() {
5849 return Err(serde::de::Error::duplicate_field("hostname"));
5850 }
5851 hostname__ = Some(map_.next_value()?);
5852 }
5853 GeneratedField::Port => {
5854 if port__.is_some() {
5855 return Err(serde::de::Error::duplicate_field("port"));
5856 }
5857 port__ = Some(map_.next_value()?);
5858 }
5859 GeneratedField::Username => {
5860 if username__.is_some() {
5861 return Err(serde::de::Error::duplicate_field("username"));
5862 }
5863 username__ = Some(map_.next_value()?);
5864 }
5865 GeneratedField::Password => {
5866 if password__.is_some() {
5867 return Err(serde::de::Error::duplicate_field("password"));
5868 }
5869 password__ = Some(map_.next_value()?);
5870 }
5871 GeneratedField::Database => {
5872 if database__.is_some() {
5873 return Err(serde::de::Error::duplicate_field("database"));
5874 }
5875 database__ = Some(map_.next_value()?);
5876 }
5877 GeneratedField::Query => {
5878 if query__.is_some() {
5879 return Err(serde::de::Error::duplicate_field("query"));
5880 }
5881 query__ = Some(map_.next_value()?);
5882 }
5883 GeneratedField::SslMode => {
5884 if ssl_mode__.is_some() {
5885 return Err(serde::de::Error::duplicate_field("sslMode"));
5886 }
5887 ssl_mode__ = Some(map_.next_value()?);
5888 }
5889 GeneratedField::SslRootCert => {
5890 if ssl_root_cert__.is_some() {
5891 return Err(serde::de::Error::duplicate_field("sslRootCert"));
5892 }
5893 ssl_root_cert__ = Some(map_.next_value()?);
5894 }
5895 }
5896 }
5897 Ok(PostgresQueryNode {
5898 columns: columns__.unwrap_or_default(),
5899 hostname: hostname__.unwrap_or_default(),
5900 port: port__.unwrap_or_default(),
5901 username: username__.unwrap_or_default(),
5902 password: password__.unwrap_or_default(),
5903 database: database__.unwrap_or_default(),
5904 query: query__.unwrap_or_default(),
5905 ssl_mode: ssl_mode__.unwrap_or_default(),
5906 ssl_root_cert: ssl_root_cert__.unwrap_or_default(),
5907 })
5908 }
5909 }
5910 deserializer.deserialize_struct("batch_plan.PostgresQueryNode", FIELDS, GeneratedVisitor)
5911 }
5912}
5913impl serde::Serialize for ProjectNode {
5914 #[allow(deprecated)]
5915 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5916 where
5917 S: serde::Serializer,
5918 {
5919 use serde::ser::SerializeStruct;
5920 let mut len = 0;
5921 if !self.select_list.is_empty() {
5922 len += 1;
5923 }
5924 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectNode", len)?;
5925 if !self.select_list.is_empty() {
5926 struct_ser.serialize_field("selectList", &self.select_list)?;
5927 }
5928 struct_ser.end()
5929 }
5930}
5931impl<'de> serde::Deserialize<'de> for ProjectNode {
5932 #[allow(deprecated)]
5933 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5934 where
5935 D: serde::Deserializer<'de>,
5936 {
5937 const FIELDS: &[&str] = &[
5938 "select_list",
5939 "selectList",
5940 ];
5941
5942 #[allow(clippy::enum_variant_names)]
5943 enum GeneratedField {
5944 SelectList,
5945 }
5946 impl<'de> serde::Deserialize<'de> for GeneratedField {
5947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5948 where
5949 D: serde::Deserializer<'de>,
5950 {
5951 struct GeneratedVisitor;
5952
5953 impl serde::de::Visitor<'_> for GeneratedVisitor {
5954 type Value = GeneratedField;
5955
5956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5957 write!(formatter, "expected one of: {:?}", &FIELDS)
5958 }
5959
5960 #[allow(unused_variables)]
5961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5962 where
5963 E: serde::de::Error,
5964 {
5965 match value {
5966 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5967 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5968 }
5969 }
5970 }
5971 deserializer.deserialize_identifier(GeneratedVisitor)
5972 }
5973 }
5974 struct GeneratedVisitor;
5975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5976 type Value = ProjectNode;
5977
5978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5979 formatter.write_str("struct batch_plan.ProjectNode")
5980 }
5981
5982 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
5983 where
5984 V: serde::de::MapAccess<'de>,
5985 {
5986 let mut select_list__ = None;
5987 while let Some(k) = map_.next_key()? {
5988 match k {
5989 GeneratedField::SelectList => {
5990 if select_list__.is_some() {
5991 return Err(serde::de::Error::duplicate_field("selectList"));
5992 }
5993 select_list__ = Some(map_.next_value()?);
5994 }
5995 }
5996 }
5997 Ok(ProjectNode {
5998 select_list: select_list__.unwrap_or_default(),
5999 })
6000 }
6001 }
6002 deserializer.deserialize_struct("batch_plan.ProjectNode", FIELDS, GeneratedVisitor)
6003 }
6004}
6005impl serde::Serialize for ProjectSetNode {
6006 #[allow(deprecated)]
6007 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6008 where
6009 S: serde::Serializer,
6010 {
6011 use serde::ser::SerializeStruct;
6012 let mut len = 0;
6013 if !self.select_list.is_empty() {
6014 len += 1;
6015 }
6016 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectSetNode", len)?;
6017 if !self.select_list.is_empty() {
6018 struct_ser.serialize_field("selectList", &self.select_list)?;
6019 }
6020 struct_ser.end()
6021 }
6022}
6023impl<'de> serde::Deserialize<'de> for ProjectSetNode {
6024 #[allow(deprecated)]
6025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6026 where
6027 D: serde::Deserializer<'de>,
6028 {
6029 const FIELDS: &[&str] = &[
6030 "select_list",
6031 "selectList",
6032 ];
6033
6034 #[allow(clippy::enum_variant_names)]
6035 enum GeneratedField {
6036 SelectList,
6037 }
6038 impl<'de> serde::Deserialize<'de> for GeneratedField {
6039 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6040 where
6041 D: serde::Deserializer<'de>,
6042 {
6043 struct GeneratedVisitor;
6044
6045 impl serde::de::Visitor<'_> for GeneratedVisitor {
6046 type Value = GeneratedField;
6047
6048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6049 write!(formatter, "expected one of: {:?}", &FIELDS)
6050 }
6051
6052 #[allow(unused_variables)]
6053 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6054 where
6055 E: serde::de::Error,
6056 {
6057 match value {
6058 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
6059 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6060 }
6061 }
6062 }
6063 deserializer.deserialize_identifier(GeneratedVisitor)
6064 }
6065 }
6066 struct GeneratedVisitor;
6067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6068 type Value = ProjectSetNode;
6069
6070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6071 formatter.write_str("struct batch_plan.ProjectSetNode")
6072 }
6073
6074 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
6075 where
6076 V: serde::de::MapAccess<'de>,
6077 {
6078 let mut select_list__ = None;
6079 while let Some(k) = map_.next_key()? {
6080 match k {
6081 GeneratedField::SelectList => {
6082 if select_list__.is_some() {
6083 return Err(serde::de::Error::duplicate_field("selectList"));
6084 }
6085 select_list__ = Some(map_.next_value()?);
6086 }
6087 }
6088 }
6089 Ok(ProjectSetNode {
6090 select_list: select_list__.unwrap_or_default(),
6091 })
6092 }
6093 }
6094 deserializer.deserialize_struct("batch_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
6095 }
6096}
6097impl serde::Serialize for RowSeqScanNode {
6098 #[allow(deprecated)]
6099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6100 where
6101 S: serde::Serializer,
6102 {
6103 use serde::ser::SerializeStruct;
6104 let mut len = 0;
6105 if self.table_desc.is_some() {
6106 len += 1;
6107 }
6108 if !self.column_ids.is_empty() {
6109 len += 1;
6110 }
6111 if !self.scan_ranges.is_empty() {
6112 len += 1;
6113 }
6114 if self.vnode_bitmap.is_some() {
6115 len += 1;
6116 }
6117 if self.ordered {
6118 len += 1;
6119 }
6120 if self.limit.is_some() {
6121 len += 1;
6122 }
6123 if self.query_epoch.is_some() {
6124 len += 1;
6125 }
6126 let mut struct_ser = serializer.serialize_struct("batch_plan.RowSeqScanNode", len)?;
6127 if let Some(v) = self.table_desc.as_ref() {
6128 struct_ser.serialize_field("tableDesc", v)?;
6129 }
6130 if !self.column_ids.is_empty() {
6131 struct_ser.serialize_field("columnIds", &self.column_ids)?;
6132 }
6133 if !self.scan_ranges.is_empty() {
6134 struct_ser.serialize_field("scanRanges", &self.scan_ranges)?;
6135 }
6136 if let Some(v) = self.vnode_bitmap.as_ref() {
6137 struct_ser.serialize_field("vnodeBitmap", v)?;
6138 }
6139 if self.ordered {
6140 struct_ser.serialize_field("ordered", &self.ordered)?;
6141 }
6142 if let Some(v) = self.limit.as_ref() {
6143 #[allow(clippy::needless_borrow)]
6144 #[allow(clippy::needless_borrows_for_generic_args)]
6145 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
6146 }
6147 if let Some(v) = self.query_epoch.as_ref() {
6148 struct_ser.serialize_field("queryEpoch", v)?;
6149 }
6150 struct_ser.end()
6151 }
6152}
6153impl<'de> serde::Deserialize<'de> for RowSeqScanNode {
6154 #[allow(deprecated)]
6155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6156 where
6157 D: serde::Deserializer<'de>,
6158 {
6159 const FIELDS: &[&str] = &[
6160 "table_desc",
6161 "tableDesc",
6162 "column_ids",
6163 "columnIds",
6164 "scan_ranges",
6165 "scanRanges",
6166 "vnode_bitmap",
6167 "vnodeBitmap",
6168 "ordered",
6169 "limit",
6170 "query_epoch",
6171 "queryEpoch",
6172 ];
6173
6174 #[allow(clippy::enum_variant_names)]
6175 enum GeneratedField {
6176 TableDesc,
6177 ColumnIds,
6178 ScanRanges,
6179 VnodeBitmap,
6180 Ordered,
6181 Limit,
6182 QueryEpoch,
6183 }
6184 impl<'de> serde::Deserialize<'de> for GeneratedField {
6185 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6186 where
6187 D: serde::Deserializer<'de>,
6188 {
6189 struct GeneratedVisitor;
6190
6191 impl serde::de::Visitor<'_> for GeneratedVisitor {
6192 type Value = GeneratedField;
6193
6194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6195 write!(formatter, "expected one of: {:?}", &FIELDS)
6196 }
6197
6198 #[allow(unused_variables)]
6199 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6200 where
6201 E: serde::de::Error,
6202 {
6203 match value {
6204 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
6205 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
6206 "scanRanges" | "scan_ranges" => Ok(GeneratedField::ScanRanges),
6207 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
6208 "ordered" => Ok(GeneratedField::Ordered),
6209 "limit" => Ok(GeneratedField::Limit),
6210 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
6211 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6212 }
6213 }
6214 }
6215 deserializer.deserialize_identifier(GeneratedVisitor)
6216 }
6217 }
6218 struct GeneratedVisitor;
6219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6220 type Value = RowSeqScanNode;
6221
6222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6223 formatter.write_str("struct batch_plan.RowSeqScanNode")
6224 }
6225
6226 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowSeqScanNode, V::Error>
6227 where
6228 V: serde::de::MapAccess<'de>,
6229 {
6230 let mut table_desc__ = None;
6231 let mut column_ids__ = None;
6232 let mut scan_ranges__ = None;
6233 let mut vnode_bitmap__ = None;
6234 let mut ordered__ = None;
6235 let mut limit__ = None;
6236 let mut query_epoch__ = None;
6237 while let Some(k) = map_.next_key()? {
6238 match k {
6239 GeneratedField::TableDesc => {
6240 if table_desc__.is_some() {
6241 return Err(serde::de::Error::duplicate_field("tableDesc"));
6242 }
6243 table_desc__ = map_.next_value()?;
6244 }
6245 GeneratedField::ColumnIds => {
6246 if column_ids__.is_some() {
6247 return Err(serde::de::Error::duplicate_field("columnIds"));
6248 }
6249 column_ids__ =
6250 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6251 .into_iter().map(|x| x.0).collect())
6252 ;
6253 }
6254 GeneratedField::ScanRanges => {
6255 if scan_ranges__.is_some() {
6256 return Err(serde::de::Error::duplicate_field("scanRanges"));
6257 }
6258 scan_ranges__ = Some(map_.next_value()?);
6259 }
6260 GeneratedField::VnodeBitmap => {
6261 if vnode_bitmap__.is_some() {
6262 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
6263 }
6264 vnode_bitmap__ = map_.next_value()?;
6265 }
6266 GeneratedField::Ordered => {
6267 if ordered__.is_some() {
6268 return Err(serde::de::Error::duplicate_field("ordered"));
6269 }
6270 ordered__ = Some(map_.next_value()?);
6271 }
6272 GeneratedField::Limit => {
6273 if limit__.is_some() {
6274 return Err(serde::de::Error::duplicate_field("limit"));
6275 }
6276 limit__ =
6277 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6278 ;
6279 }
6280 GeneratedField::QueryEpoch => {
6281 if query_epoch__.is_some() {
6282 return Err(serde::de::Error::duplicate_field("queryEpoch"));
6283 }
6284 query_epoch__ = map_.next_value()?;
6285 }
6286 }
6287 }
6288 Ok(RowSeqScanNode {
6289 table_desc: table_desc__,
6290 column_ids: column_ids__.unwrap_or_default(),
6291 scan_ranges: scan_ranges__.unwrap_or_default(),
6292 vnode_bitmap: vnode_bitmap__,
6293 ordered: ordered__.unwrap_or_default(),
6294 limit: limit__,
6295 query_epoch: query_epoch__,
6296 })
6297 }
6298 }
6299 deserializer.deserialize_struct("batch_plan.RowSeqScanNode", FIELDS, GeneratedVisitor)
6300 }
6301}
6302impl serde::Serialize for ScanRange {
6303 #[allow(deprecated)]
6304 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6305 where
6306 S: serde::Serializer,
6307 {
6308 use serde::ser::SerializeStruct;
6309 let mut len = 0;
6310 if !self.eq_conds.is_empty() {
6311 len += 1;
6312 }
6313 if self.lower_bound.is_some() {
6314 len += 1;
6315 }
6316 if self.upper_bound.is_some() {
6317 len += 1;
6318 }
6319 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange", len)?;
6320 if !self.eq_conds.is_empty() {
6321 struct_ser.serialize_field("eqConds", &self.eq_conds.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6322 }
6323 if let Some(v) = self.lower_bound.as_ref() {
6324 struct_ser.serialize_field("lowerBound", v)?;
6325 }
6326 if let Some(v) = self.upper_bound.as_ref() {
6327 struct_ser.serialize_field("upperBound", v)?;
6328 }
6329 struct_ser.end()
6330 }
6331}
6332impl<'de> serde::Deserialize<'de> for ScanRange {
6333 #[allow(deprecated)]
6334 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6335 where
6336 D: serde::Deserializer<'de>,
6337 {
6338 const FIELDS: &[&str] = &[
6339 "eq_conds",
6340 "eqConds",
6341 "lower_bound",
6342 "lowerBound",
6343 "upper_bound",
6344 "upperBound",
6345 ];
6346
6347 #[allow(clippy::enum_variant_names)]
6348 enum GeneratedField {
6349 EqConds,
6350 LowerBound,
6351 UpperBound,
6352 }
6353 impl<'de> serde::Deserialize<'de> for GeneratedField {
6354 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6355 where
6356 D: serde::Deserializer<'de>,
6357 {
6358 struct GeneratedVisitor;
6359
6360 impl serde::de::Visitor<'_> for GeneratedVisitor {
6361 type Value = GeneratedField;
6362
6363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6364 write!(formatter, "expected one of: {:?}", &FIELDS)
6365 }
6366
6367 #[allow(unused_variables)]
6368 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6369 where
6370 E: serde::de::Error,
6371 {
6372 match value {
6373 "eqConds" | "eq_conds" => Ok(GeneratedField::EqConds),
6374 "lowerBound" | "lower_bound" => Ok(GeneratedField::LowerBound),
6375 "upperBound" | "upper_bound" => Ok(GeneratedField::UpperBound),
6376 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6377 }
6378 }
6379 }
6380 deserializer.deserialize_identifier(GeneratedVisitor)
6381 }
6382 }
6383 struct GeneratedVisitor;
6384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6385 type Value = ScanRange;
6386
6387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6388 formatter.write_str("struct batch_plan.ScanRange")
6389 }
6390
6391 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScanRange, V::Error>
6392 where
6393 V: serde::de::MapAccess<'de>,
6394 {
6395 let mut eq_conds__ = None;
6396 let mut lower_bound__ = None;
6397 let mut upper_bound__ = None;
6398 while let Some(k) = map_.next_key()? {
6399 match k {
6400 GeneratedField::EqConds => {
6401 if eq_conds__.is_some() {
6402 return Err(serde::de::Error::duplicate_field("eqConds"));
6403 }
6404 eq_conds__ =
6405 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6406 .into_iter().map(|x| x.0).collect())
6407 ;
6408 }
6409 GeneratedField::LowerBound => {
6410 if lower_bound__.is_some() {
6411 return Err(serde::de::Error::duplicate_field("lowerBound"));
6412 }
6413 lower_bound__ = map_.next_value()?;
6414 }
6415 GeneratedField::UpperBound => {
6416 if upper_bound__.is_some() {
6417 return Err(serde::de::Error::duplicate_field("upperBound"));
6418 }
6419 upper_bound__ = map_.next_value()?;
6420 }
6421 }
6422 }
6423 Ok(ScanRange {
6424 eq_conds: eq_conds__.unwrap_or_default(),
6425 lower_bound: lower_bound__,
6426 upper_bound: upper_bound__,
6427 })
6428 }
6429 }
6430 deserializer.deserialize_struct("batch_plan.ScanRange", FIELDS, GeneratedVisitor)
6431 }
6432}
6433impl serde::Serialize for scan_range::Bound {
6434 #[allow(deprecated)]
6435 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6436 where
6437 S: serde::Serializer,
6438 {
6439 use serde::ser::SerializeStruct;
6440 let mut len = 0;
6441 if !self.value.is_empty() {
6442 len += 1;
6443 }
6444 if self.inclusive {
6445 len += 1;
6446 }
6447 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange.Bound", len)?;
6448 if !self.value.is_empty() {
6449 struct_ser.serialize_field("value", &self.value.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6450 }
6451 if self.inclusive {
6452 struct_ser.serialize_field("inclusive", &self.inclusive)?;
6453 }
6454 struct_ser.end()
6455 }
6456}
6457impl<'de> serde::Deserialize<'de> for scan_range::Bound {
6458 #[allow(deprecated)]
6459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6460 where
6461 D: serde::Deserializer<'de>,
6462 {
6463 const FIELDS: &[&str] = &[
6464 "value",
6465 "inclusive",
6466 ];
6467
6468 #[allow(clippy::enum_variant_names)]
6469 enum GeneratedField {
6470 Value,
6471 Inclusive,
6472 }
6473 impl<'de> serde::Deserialize<'de> for GeneratedField {
6474 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6475 where
6476 D: serde::Deserializer<'de>,
6477 {
6478 struct GeneratedVisitor;
6479
6480 impl serde::de::Visitor<'_> for GeneratedVisitor {
6481 type Value = GeneratedField;
6482
6483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6484 write!(formatter, "expected one of: {:?}", &FIELDS)
6485 }
6486
6487 #[allow(unused_variables)]
6488 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6489 where
6490 E: serde::de::Error,
6491 {
6492 match value {
6493 "value" => Ok(GeneratedField::Value),
6494 "inclusive" => Ok(GeneratedField::Inclusive),
6495 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6496 }
6497 }
6498 }
6499 deserializer.deserialize_identifier(GeneratedVisitor)
6500 }
6501 }
6502 struct GeneratedVisitor;
6503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6504 type Value = scan_range::Bound;
6505
6506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6507 formatter.write_str("struct batch_plan.ScanRange.Bound")
6508 }
6509
6510 fn visit_map<V>(self, mut map_: V) -> std::result::Result<scan_range::Bound, V::Error>
6511 where
6512 V: serde::de::MapAccess<'de>,
6513 {
6514 let mut value__ = None;
6515 let mut inclusive__ = None;
6516 while let Some(k) = map_.next_key()? {
6517 match k {
6518 GeneratedField::Value => {
6519 if value__.is_some() {
6520 return Err(serde::de::Error::duplicate_field("value"));
6521 }
6522 value__ =
6523 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6524 .into_iter().map(|x| x.0).collect())
6525 ;
6526 }
6527 GeneratedField::Inclusive => {
6528 if inclusive__.is_some() {
6529 return Err(serde::de::Error::duplicate_field("inclusive"));
6530 }
6531 inclusive__ = Some(map_.next_value()?);
6532 }
6533 }
6534 }
6535 Ok(scan_range::Bound {
6536 value: value__.unwrap_or_default(),
6537 inclusive: inclusive__.unwrap_or_default(),
6538 })
6539 }
6540 }
6541 deserializer.deserialize_struct("batch_plan.ScanRange.Bound", FIELDS, GeneratedVisitor)
6542 }
6543}
6544impl serde::Serialize for SortAggNode {
6545 #[allow(deprecated)]
6546 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6547 where
6548 S: serde::Serializer,
6549 {
6550 use serde::ser::SerializeStruct;
6551 let mut len = 0;
6552 if !self.group_key.is_empty() {
6553 len += 1;
6554 }
6555 if !self.agg_calls.is_empty() {
6556 len += 1;
6557 }
6558 let mut struct_ser = serializer.serialize_struct("batch_plan.SortAggNode", len)?;
6559 if !self.group_key.is_empty() {
6560 struct_ser.serialize_field("groupKey", &self.group_key)?;
6561 }
6562 if !self.agg_calls.is_empty() {
6563 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6564 }
6565 struct_ser.end()
6566 }
6567}
6568impl<'de> serde::Deserialize<'de> for SortAggNode {
6569 #[allow(deprecated)]
6570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6571 where
6572 D: serde::Deserializer<'de>,
6573 {
6574 const FIELDS: &[&str] = &[
6575 "group_key",
6576 "groupKey",
6577 "agg_calls",
6578 "aggCalls",
6579 ];
6580
6581 #[allow(clippy::enum_variant_names)]
6582 enum GeneratedField {
6583 GroupKey,
6584 AggCalls,
6585 }
6586 impl<'de> serde::Deserialize<'de> for GeneratedField {
6587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6588 where
6589 D: serde::Deserializer<'de>,
6590 {
6591 struct GeneratedVisitor;
6592
6593 impl serde::de::Visitor<'_> for GeneratedVisitor {
6594 type Value = GeneratedField;
6595
6596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6597 write!(formatter, "expected one of: {:?}", &FIELDS)
6598 }
6599
6600 #[allow(unused_variables)]
6601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6602 where
6603 E: serde::de::Error,
6604 {
6605 match value {
6606 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6607 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6608 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6609 }
6610 }
6611 }
6612 deserializer.deserialize_identifier(GeneratedVisitor)
6613 }
6614 }
6615 struct GeneratedVisitor;
6616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6617 type Value = SortAggNode;
6618
6619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6620 formatter.write_str("struct batch_plan.SortAggNode")
6621 }
6622
6623 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortAggNode, V::Error>
6624 where
6625 V: serde::de::MapAccess<'de>,
6626 {
6627 let mut group_key__ = None;
6628 let mut agg_calls__ = None;
6629 while let Some(k) = map_.next_key()? {
6630 match k {
6631 GeneratedField::GroupKey => {
6632 if group_key__.is_some() {
6633 return Err(serde::de::Error::duplicate_field("groupKey"));
6634 }
6635 group_key__ = Some(map_.next_value()?);
6636 }
6637 GeneratedField::AggCalls => {
6638 if agg_calls__.is_some() {
6639 return Err(serde::de::Error::duplicate_field("aggCalls"));
6640 }
6641 agg_calls__ = Some(map_.next_value()?);
6642 }
6643 }
6644 }
6645 Ok(SortAggNode {
6646 group_key: group_key__.unwrap_or_default(),
6647 agg_calls: agg_calls__.unwrap_or_default(),
6648 })
6649 }
6650 }
6651 deserializer.deserialize_struct("batch_plan.SortAggNode", FIELDS, GeneratedVisitor)
6652 }
6653}
6654impl serde::Serialize for SortMergeJoinNode {
6655 #[allow(deprecated)]
6656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6657 where
6658 S: serde::Serializer,
6659 {
6660 use serde::ser::SerializeStruct;
6661 let mut len = 0;
6662 if self.join_type != 0 {
6663 len += 1;
6664 }
6665 if !self.left_key.is_empty() {
6666 len += 1;
6667 }
6668 if !self.right_key.is_empty() {
6669 len += 1;
6670 }
6671 if self.direction != 0 {
6672 len += 1;
6673 }
6674 if !self.output_indices.is_empty() {
6675 len += 1;
6676 }
6677 let mut struct_ser = serializer.serialize_struct("batch_plan.SortMergeJoinNode", len)?;
6678 if self.join_type != 0 {
6679 let v = super::plan_common::JoinType::try_from(self.join_type)
6680 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6681 struct_ser.serialize_field("joinType", &v)?;
6682 }
6683 if !self.left_key.is_empty() {
6684 struct_ser.serialize_field("leftKey", &self.left_key)?;
6685 }
6686 if !self.right_key.is_empty() {
6687 struct_ser.serialize_field("rightKey", &self.right_key)?;
6688 }
6689 if self.direction != 0 {
6690 let v = super::common::Direction::try_from(self.direction)
6691 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
6692 struct_ser.serialize_field("direction", &v)?;
6693 }
6694 if !self.output_indices.is_empty() {
6695 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6696 }
6697 struct_ser.end()
6698 }
6699}
6700impl<'de> serde::Deserialize<'de> for SortMergeJoinNode {
6701 #[allow(deprecated)]
6702 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6703 where
6704 D: serde::Deserializer<'de>,
6705 {
6706 const FIELDS: &[&str] = &[
6707 "join_type",
6708 "joinType",
6709 "left_key",
6710 "leftKey",
6711 "right_key",
6712 "rightKey",
6713 "direction",
6714 "output_indices",
6715 "outputIndices",
6716 ];
6717
6718 #[allow(clippy::enum_variant_names)]
6719 enum GeneratedField {
6720 JoinType,
6721 LeftKey,
6722 RightKey,
6723 Direction,
6724 OutputIndices,
6725 }
6726 impl<'de> serde::Deserialize<'de> for GeneratedField {
6727 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6728 where
6729 D: serde::Deserializer<'de>,
6730 {
6731 struct GeneratedVisitor;
6732
6733 impl serde::de::Visitor<'_> for GeneratedVisitor {
6734 type Value = GeneratedField;
6735
6736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6737 write!(formatter, "expected one of: {:?}", &FIELDS)
6738 }
6739
6740 #[allow(unused_variables)]
6741 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6742 where
6743 E: serde::de::Error,
6744 {
6745 match value {
6746 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6747 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6748 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6749 "direction" => Ok(GeneratedField::Direction),
6750 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6751 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6752 }
6753 }
6754 }
6755 deserializer.deserialize_identifier(GeneratedVisitor)
6756 }
6757 }
6758 struct GeneratedVisitor;
6759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6760 type Value = SortMergeJoinNode;
6761
6762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6763 formatter.write_str("struct batch_plan.SortMergeJoinNode")
6764 }
6765
6766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortMergeJoinNode, V::Error>
6767 where
6768 V: serde::de::MapAccess<'de>,
6769 {
6770 let mut join_type__ = None;
6771 let mut left_key__ = None;
6772 let mut right_key__ = None;
6773 let mut direction__ = None;
6774 let mut output_indices__ = None;
6775 while let Some(k) = map_.next_key()? {
6776 match k {
6777 GeneratedField::JoinType => {
6778 if join_type__.is_some() {
6779 return Err(serde::de::Error::duplicate_field("joinType"));
6780 }
6781 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6782 }
6783 GeneratedField::LeftKey => {
6784 if left_key__.is_some() {
6785 return Err(serde::de::Error::duplicate_field("leftKey"));
6786 }
6787 left_key__ =
6788 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6789 .into_iter().map(|x| x.0).collect())
6790 ;
6791 }
6792 GeneratedField::RightKey => {
6793 if right_key__.is_some() {
6794 return Err(serde::de::Error::duplicate_field("rightKey"));
6795 }
6796 right_key__ =
6797 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6798 .into_iter().map(|x| x.0).collect())
6799 ;
6800 }
6801 GeneratedField::Direction => {
6802 if direction__.is_some() {
6803 return Err(serde::de::Error::duplicate_field("direction"));
6804 }
6805 direction__ = Some(map_.next_value::<super::common::Direction>()? as i32);
6806 }
6807 GeneratedField::OutputIndices => {
6808 if output_indices__.is_some() {
6809 return Err(serde::de::Error::duplicate_field("outputIndices"));
6810 }
6811 output_indices__ =
6812 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6813 .into_iter().map(|x| x.0).collect())
6814 ;
6815 }
6816 }
6817 }
6818 Ok(SortMergeJoinNode {
6819 join_type: join_type__.unwrap_or_default(),
6820 left_key: left_key__.unwrap_or_default(),
6821 right_key: right_key__.unwrap_or_default(),
6822 direction: direction__.unwrap_or_default(),
6823 output_indices: output_indices__.unwrap_or_default(),
6824 })
6825 }
6826 }
6827 deserializer.deserialize_struct("batch_plan.SortMergeJoinNode", FIELDS, GeneratedVisitor)
6828 }
6829}
6830impl serde::Serialize for SortNode {
6831 #[allow(deprecated)]
6832 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6833 where
6834 S: serde::Serializer,
6835 {
6836 use serde::ser::SerializeStruct;
6837 let mut len = 0;
6838 if !self.column_orders.is_empty() {
6839 len += 1;
6840 }
6841 let mut struct_ser = serializer.serialize_struct("batch_plan.SortNode", len)?;
6842 if !self.column_orders.is_empty() {
6843 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6844 }
6845 struct_ser.end()
6846 }
6847}
6848impl<'de> serde::Deserialize<'de> for SortNode {
6849 #[allow(deprecated)]
6850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6851 where
6852 D: serde::Deserializer<'de>,
6853 {
6854 const FIELDS: &[&str] = &[
6855 "column_orders",
6856 "columnOrders",
6857 ];
6858
6859 #[allow(clippy::enum_variant_names)]
6860 enum GeneratedField {
6861 ColumnOrders,
6862 }
6863 impl<'de> serde::Deserialize<'de> for GeneratedField {
6864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6865 where
6866 D: serde::Deserializer<'de>,
6867 {
6868 struct GeneratedVisitor;
6869
6870 impl serde::de::Visitor<'_> for GeneratedVisitor {
6871 type Value = GeneratedField;
6872
6873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6874 write!(formatter, "expected one of: {:?}", &FIELDS)
6875 }
6876
6877 #[allow(unused_variables)]
6878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6879 where
6880 E: serde::de::Error,
6881 {
6882 match value {
6883 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6884 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6885 }
6886 }
6887 }
6888 deserializer.deserialize_identifier(GeneratedVisitor)
6889 }
6890 }
6891 struct GeneratedVisitor;
6892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6893 type Value = SortNode;
6894
6895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6896 formatter.write_str("struct batch_plan.SortNode")
6897 }
6898
6899 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
6900 where
6901 V: serde::de::MapAccess<'de>,
6902 {
6903 let mut column_orders__ = None;
6904 while let Some(k) = map_.next_key()? {
6905 match k {
6906 GeneratedField::ColumnOrders => {
6907 if column_orders__.is_some() {
6908 return Err(serde::de::Error::duplicate_field("columnOrders"));
6909 }
6910 column_orders__ = Some(map_.next_value()?);
6911 }
6912 }
6913 }
6914 Ok(SortNode {
6915 column_orders: column_orders__.unwrap_or_default(),
6916 })
6917 }
6918 }
6919 deserializer.deserialize_struct("batch_plan.SortNode", FIELDS, GeneratedVisitor)
6920 }
6921}
6922impl serde::Serialize for SortOverWindowNode {
6923 #[allow(deprecated)]
6924 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6925 where
6926 S: serde::Serializer,
6927 {
6928 use serde::ser::SerializeStruct;
6929 let mut len = 0;
6930 if !self.calls.is_empty() {
6931 len += 1;
6932 }
6933 if !self.partition_by.is_empty() {
6934 len += 1;
6935 }
6936 if !self.order_by.is_empty() {
6937 len += 1;
6938 }
6939 let mut struct_ser = serializer.serialize_struct("batch_plan.SortOverWindowNode", len)?;
6940 if !self.calls.is_empty() {
6941 struct_ser.serialize_field("calls", &self.calls)?;
6942 }
6943 if !self.partition_by.is_empty() {
6944 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
6945 }
6946 if !self.order_by.is_empty() {
6947 struct_ser.serialize_field("orderBy", &self.order_by)?;
6948 }
6949 struct_ser.end()
6950 }
6951}
6952impl<'de> serde::Deserialize<'de> for SortOverWindowNode {
6953 #[allow(deprecated)]
6954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6955 where
6956 D: serde::Deserializer<'de>,
6957 {
6958 const FIELDS: &[&str] = &[
6959 "calls",
6960 "partition_by",
6961 "partitionBy",
6962 "order_by",
6963 "orderBy",
6964 ];
6965
6966 #[allow(clippy::enum_variant_names)]
6967 enum GeneratedField {
6968 Calls,
6969 PartitionBy,
6970 OrderBy,
6971 }
6972 impl<'de> serde::Deserialize<'de> for GeneratedField {
6973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6974 where
6975 D: serde::Deserializer<'de>,
6976 {
6977 struct GeneratedVisitor;
6978
6979 impl serde::de::Visitor<'_> for GeneratedVisitor {
6980 type Value = GeneratedField;
6981
6982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6983 write!(formatter, "expected one of: {:?}", &FIELDS)
6984 }
6985
6986 #[allow(unused_variables)]
6987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6988 where
6989 E: serde::de::Error,
6990 {
6991 match value {
6992 "calls" => Ok(GeneratedField::Calls),
6993 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
6994 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
6995 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6996 }
6997 }
6998 }
6999 deserializer.deserialize_identifier(GeneratedVisitor)
7000 }
7001 }
7002 struct GeneratedVisitor;
7003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7004 type Value = SortOverWindowNode;
7005
7006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7007 formatter.write_str("struct batch_plan.SortOverWindowNode")
7008 }
7009
7010 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortOverWindowNode, V::Error>
7011 where
7012 V: serde::de::MapAccess<'de>,
7013 {
7014 let mut calls__ = None;
7015 let mut partition_by__ = None;
7016 let mut order_by__ = None;
7017 while let Some(k) = map_.next_key()? {
7018 match k {
7019 GeneratedField::Calls => {
7020 if calls__.is_some() {
7021 return Err(serde::de::Error::duplicate_field("calls"));
7022 }
7023 calls__ = Some(map_.next_value()?);
7024 }
7025 GeneratedField::PartitionBy => {
7026 if partition_by__.is_some() {
7027 return Err(serde::de::Error::duplicate_field("partitionBy"));
7028 }
7029 partition_by__ =
7030 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7031 .into_iter().map(|x| x.0).collect())
7032 ;
7033 }
7034 GeneratedField::OrderBy => {
7035 if order_by__.is_some() {
7036 return Err(serde::de::Error::duplicate_field("orderBy"));
7037 }
7038 order_by__ = Some(map_.next_value()?);
7039 }
7040 }
7041 }
7042 Ok(SortOverWindowNode {
7043 calls: calls__.unwrap_or_default(),
7044 partition_by: partition_by__.unwrap_or_default(),
7045 order_by: order_by__.unwrap_or_default(),
7046 })
7047 }
7048 }
7049 deserializer.deserialize_struct("batch_plan.SortOverWindowNode", FIELDS, GeneratedVisitor)
7050 }
7051}
7052impl serde::Serialize for SourceNode {
7053 #[allow(deprecated)]
7054 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7055 where
7056 S: serde::Serializer,
7057 {
7058 use serde::ser::SerializeStruct;
7059 let mut len = 0;
7060 if self.source_id != 0 {
7061 len += 1;
7062 }
7063 if !self.columns.is_empty() {
7064 len += 1;
7065 }
7066 if !self.with_properties.is_empty() {
7067 len += 1;
7068 }
7069 if !self.split.is_empty() {
7070 len += 1;
7071 }
7072 if self.info.is_some() {
7073 len += 1;
7074 }
7075 if !self.secret_refs.is_empty() {
7076 len += 1;
7077 }
7078 let mut struct_ser = serializer.serialize_struct("batch_plan.SourceNode", len)?;
7079 if self.source_id != 0 {
7080 struct_ser.serialize_field("sourceId", &self.source_id)?;
7081 }
7082 if !self.columns.is_empty() {
7083 struct_ser.serialize_field("columns", &self.columns)?;
7084 }
7085 if !self.with_properties.is_empty() {
7086 struct_ser.serialize_field("withProperties", &self.with_properties)?;
7087 }
7088 if !self.split.is_empty() {
7089 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
7090 }
7091 if let Some(v) = self.info.as_ref() {
7092 struct_ser.serialize_field("info", v)?;
7093 }
7094 if !self.secret_refs.is_empty() {
7095 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
7096 }
7097 struct_ser.end()
7098 }
7099}
7100impl<'de> serde::Deserialize<'de> for SourceNode {
7101 #[allow(deprecated)]
7102 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7103 where
7104 D: serde::Deserializer<'de>,
7105 {
7106 const FIELDS: &[&str] = &[
7107 "source_id",
7108 "sourceId",
7109 "columns",
7110 "with_properties",
7111 "withProperties",
7112 "split",
7113 "info",
7114 "secret_refs",
7115 "secretRefs",
7116 ];
7117
7118 #[allow(clippy::enum_variant_names)]
7119 enum GeneratedField {
7120 SourceId,
7121 Columns,
7122 WithProperties,
7123 Split,
7124 Info,
7125 SecretRefs,
7126 }
7127 impl<'de> serde::Deserialize<'de> for GeneratedField {
7128 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7129 where
7130 D: serde::Deserializer<'de>,
7131 {
7132 struct GeneratedVisitor;
7133
7134 impl serde::de::Visitor<'_> for GeneratedVisitor {
7135 type Value = GeneratedField;
7136
7137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7138 write!(formatter, "expected one of: {:?}", &FIELDS)
7139 }
7140
7141 #[allow(unused_variables)]
7142 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7143 where
7144 E: serde::de::Error,
7145 {
7146 match value {
7147 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7148 "columns" => Ok(GeneratedField::Columns),
7149 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
7150 "split" => Ok(GeneratedField::Split),
7151 "info" => Ok(GeneratedField::Info),
7152 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
7153 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7154 }
7155 }
7156 }
7157 deserializer.deserialize_identifier(GeneratedVisitor)
7158 }
7159 }
7160 struct GeneratedVisitor;
7161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7162 type Value = SourceNode;
7163
7164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7165 formatter.write_str("struct batch_plan.SourceNode")
7166 }
7167
7168 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
7169 where
7170 V: serde::de::MapAccess<'de>,
7171 {
7172 let mut source_id__ = None;
7173 let mut columns__ = None;
7174 let mut with_properties__ = None;
7175 let mut split__ = None;
7176 let mut info__ = None;
7177 let mut secret_refs__ = None;
7178 while let Some(k) = map_.next_key()? {
7179 match k {
7180 GeneratedField::SourceId => {
7181 if source_id__.is_some() {
7182 return Err(serde::de::Error::duplicate_field("sourceId"));
7183 }
7184 source_id__ =
7185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7186 ;
7187 }
7188 GeneratedField::Columns => {
7189 if columns__.is_some() {
7190 return Err(serde::de::Error::duplicate_field("columns"));
7191 }
7192 columns__ = Some(map_.next_value()?);
7193 }
7194 GeneratedField::WithProperties => {
7195 if with_properties__.is_some() {
7196 return Err(serde::de::Error::duplicate_field("withProperties"));
7197 }
7198 with_properties__ = Some(
7199 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7200 );
7201 }
7202 GeneratedField::Split => {
7203 if split__.is_some() {
7204 return Err(serde::de::Error::duplicate_field("split"));
7205 }
7206 split__ =
7207 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7208 .into_iter().map(|x| x.0).collect())
7209 ;
7210 }
7211 GeneratedField::Info => {
7212 if info__.is_some() {
7213 return Err(serde::de::Error::duplicate_field("info"));
7214 }
7215 info__ = map_.next_value()?;
7216 }
7217 GeneratedField::SecretRefs => {
7218 if secret_refs__.is_some() {
7219 return Err(serde::de::Error::duplicate_field("secretRefs"));
7220 }
7221 secret_refs__ = Some(
7222 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7223 );
7224 }
7225 }
7226 }
7227 Ok(SourceNode {
7228 source_id: source_id__.unwrap_or_default(),
7229 columns: columns__.unwrap_or_default(),
7230 with_properties: with_properties__.unwrap_or_default(),
7231 split: split__.unwrap_or_default(),
7232 info: info__,
7233 secret_refs: secret_refs__.unwrap_or_default(),
7234 })
7235 }
7236 }
7237 deserializer.deserialize_struct("batch_plan.SourceNode", FIELDS, GeneratedVisitor)
7238 }
7239}
7240impl serde::Serialize for SysRowSeqScanNode {
7241 #[allow(deprecated)]
7242 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7243 where
7244 S: serde::Serializer,
7245 {
7246 use serde::ser::SerializeStruct;
7247 let mut len = 0;
7248 if self.table_id != 0 {
7249 len += 1;
7250 }
7251 if !self.column_descs.is_empty() {
7252 len += 1;
7253 }
7254 let mut struct_ser = serializer.serialize_struct("batch_plan.SysRowSeqScanNode", len)?;
7255 if self.table_id != 0 {
7256 struct_ser.serialize_field("tableId", &self.table_id)?;
7257 }
7258 if !self.column_descs.is_empty() {
7259 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
7260 }
7261 struct_ser.end()
7262 }
7263}
7264impl<'de> serde::Deserialize<'de> for SysRowSeqScanNode {
7265 #[allow(deprecated)]
7266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7267 where
7268 D: serde::Deserializer<'de>,
7269 {
7270 const FIELDS: &[&str] = &[
7271 "table_id",
7272 "tableId",
7273 "column_descs",
7274 "columnDescs",
7275 ];
7276
7277 #[allow(clippy::enum_variant_names)]
7278 enum GeneratedField {
7279 TableId,
7280 ColumnDescs,
7281 }
7282 impl<'de> serde::Deserialize<'de> for GeneratedField {
7283 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7284 where
7285 D: serde::Deserializer<'de>,
7286 {
7287 struct GeneratedVisitor;
7288
7289 impl serde::de::Visitor<'_> for GeneratedVisitor {
7290 type Value = GeneratedField;
7291
7292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7293 write!(formatter, "expected one of: {:?}", &FIELDS)
7294 }
7295
7296 #[allow(unused_variables)]
7297 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7298 where
7299 E: serde::de::Error,
7300 {
7301 match value {
7302 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7303 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
7304 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7305 }
7306 }
7307 }
7308 deserializer.deserialize_identifier(GeneratedVisitor)
7309 }
7310 }
7311 struct GeneratedVisitor;
7312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7313 type Value = SysRowSeqScanNode;
7314
7315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7316 formatter.write_str("struct batch_plan.SysRowSeqScanNode")
7317 }
7318
7319 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SysRowSeqScanNode, V::Error>
7320 where
7321 V: serde::de::MapAccess<'de>,
7322 {
7323 let mut table_id__ = None;
7324 let mut column_descs__ = None;
7325 while let Some(k) = map_.next_key()? {
7326 match k {
7327 GeneratedField::TableId => {
7328 if table_id__.is_some() {
7329 return Err(serde::de::Error::duplicate_field("tableId"));
7330 }
7331 table_id__ =
7332 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7333 ;
7334 }
7335 GeneratedField::ColumnDescs => {
7336 if column_descs__.is_some() {
7337 return Err(serde::de::Error::duplicate_field("columnDescs"));
7338 }
7339 column_descs__ = Some(map_.next_value()?);
7340 }
7341 }
7342 }
7343 Ok(SysRowSeqScanNode {
7344 table_id: table_id__.unwrap_or_default(),
7345 column_descs: column_descs__.unwrap_or_default(),
7346 })
7347 }
7348 }
7349 deserializer.deserialize_struct("batch_plan.SysRowSeqScanNode", FIELDS, GeneratedVisitor)
7350 }
7351}
7352impl serde::Serialize for TableFunctionNode {
7353 #[allow(deprecated)]
7354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7355 where
7356 S: serde::Serializer,
7357 {
7358 use serde::ser::SerializeStruct;
7359 let mut len = 0;
7360 if self.table_function.is_some() {
7361 len += 1;
7362 }
7363 let mut struct_ser = serializer.serialize_struct("batch_plan.TableFunctionNode", len)?;
7364 if let Some(v) = self.table_function.as_ref() {
7365 struct_ser.serialize_field("tableFunction", v)?;
7366 }
7367 struct_ser.end()
7368 }
7369}
7370impl<'de> serde::Deserialize<'de> for TableFunctionNode {
7371 #[allow(deprecated)]
7372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7373 where
7374 D: serde::Deserializer<'de>,
7375 {
7376 const FIELDS: &[&str] = &[
7377 "table_function",
7378 "tableFunction",
7379 ];
7380
7381 #[allow(clippy::enum_variant_names)]
7382 enum GeneratedField {
7383 TableFunction,
7384 }
7385 impl<'de> serde::Deserialize<'de> for GeneratedField {
7386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7387 where
7388 D: serde::Deserializer<'de>,
7389 {
7390 struct GeneratedVisitor;
7391
7392 impl serde::de::Visitor<'_> for GeneratedVisitor {
7393 type Value = GeneratedField;
7394
7395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7396 write!(formatter, "expected one of: {:?}", &FIELDS)
7397 }
7398
7399 #[allow(unused_variables)]
7400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7401 where
7402 E: serde::de::Error,
7403 {
7404 match value {
7405 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
7406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7407 }
7408 }
7409 }
7410 deserializer.deserialize_identifier(GeneratedVisitor)
7411 }
7412 }
7413 struct GeneratedVisitor;
7414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7415 type Value = TableFunctionNode;
7416
7417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7418 formatter.write_str("struct batch_plan.TableFunctionNode")
7419 }
7420
7421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunctionNode, V::Error>
7422 where
7423 V: serde::de::MapAccess<'de>,
7424 {
7425 let mut table_function__ = None;
7426 while let Some(k) = map_.next_key()? {
7427 match k {
7428 GeneratedField::TableFunction => {
7429 if table_function__.is_some() {
7430 return Err(serde::de::Error::duplicate_field("tableFunction"));
7431 }
7432 table_function__ = map_.next_value()?;
7433 }
7434 }
7435 }
7436 Ok(TableFunctionNode {
7437 table_function: table_function__,
7438 })
7439 }
7440 }
7441 deserializer.deserialize_struct("batch_plan.TableFunctionNode", FIELDS, GeneratedVisitor)
7442 }
7443}
7444impl serde::Serialize for TaskId {
7445 #[allow(deprecated)]
7446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7447 where
7448 S: serde::Serializer,
7449 {
7450 use serde::ser::SerializeStruct;
7451 let mut len = 0;
7452 if !self.query_id.is_empty() {
7453 len += 1;
7454 }
7455 if self.stage_id != 0 {
7456 len += 1;
7457 }
7458 if self.task_id != 0 {
7459 len += 1;
7460 }
7461 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskId", len)?;
7462 if !self.query_id.is_empty() {
7463 struct_ser.serialize_field("queryId", &self.query_id)?;
7464 }
7465 if self.stage_id != 0 {
7466 struct_ser.serialize_field("stageId", &self.stage_id)?;
7467 }
7468 if self.task_id != 0 {
7469 #[allow(clippy::needless_borrow)]
7470 #[allow(clippy::needless_borrows_for_generic_args)]
7471 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7472 }
7473 struct_ser.end()
7474 }
7475}
7476impl<'de> serde::Deserialize<'de> for TaskId {
7477 #[allow(deprecated)]
7478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7479 where
7480 D: serde::Deserializer<'de>,
7481 {
7482 const FIELDS: &[&str] = &[
7483 "query_id",
7484 "queryId",
7485 "stage_id",
7486 "stageId",
7487 "task_id",
7488 "taskId",
7489 ];
7490
7491 #[allow(clippy::enum_variant_names)]
7492 enum GeneratedField {
7493 QueryId,
7494 StageId,
7495 TaskId,
7496 }
7497 impl<'de> serde::Deserialize<'de> for GeneratedField {
7498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7499 where
7500 D: serde::Deserializer<'de>,
7501 {
7502 struct GeneratedVisitor;
7503
7504 impl serde::de::Visitor<'_> for GeneratedVisitor {
7505 type Value = GeneratedField;
7506
7507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7508 write!(formatter, "expected one of: {:?}", &FIELDS)
7509 }
7510
7511 #[allow(unused_variables)]
7512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7513 where
7514 E: serde::de::Error,
7515 {
7516 match value {
7517 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
7518 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
7519 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7520 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7521 }
7522 }
7523 }
7524 deserializer.deserialize_identifier(GeneratedVisitor)
7525 }
7526 }
7527 struct GeneratedVisitor;
7528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7529 type Value = TaskId;
7530
7531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7532 formatter.write_str("struct batch_plan.TaskId")
7533 }
7534
7535 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
7536 where
7537 V: serde::de::MapAccess<'de>,
7538 {
7539 let mut query_id__ = None;
7540 let mut stage_id__ = None;
7541 let mut task_id__ = None;
7542 while let Some(k) = map_.next_key()? {
7543 match k {
7544 GeneratedField::QueryId => {
7545 if query_id__.is_some() {
7546 return Err(serde::de::Error::duplicate_field("queryId"));
7547 }
7548 query_id__ = Some(map_.next_value()?);
7549 }
7550 GeneratedField::StageId => {
7551 if stage_id__.is_some() {
7552 return Err(serde::de::Error::duplicate_field("stageId"));
7553 }
7554 stage_id__ =
7555 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7556 ;
7557 }
7558 GeneratedField::TaskId => {
7559 if task_id__.is_some() {
7560 return Err(serde::de::Error::duplicate_field("taskId"));
7561 }
7562 task_id__ =
7563 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7564 ;
7565 }
7566 }
7567 }
7568 Ok(TaskId {
7569 query_id: query_id__.unwrap_or_default(),
7570 stage_id: stage_id__.unwrap_or_default(),
7571 task_id: task_id__.unwrap_or_default(),
7572 })
7573 }
7574 }
7575 deserializer.deserialize_struct("batch_plan.TaskId", FIELDS, GeneratedVisitor)
7576 }
7577}
7578impl serde::Serialize for TaskOutputId {
7579 #[allow(deprecated)]
7580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7581 where
7582 S: serde::Serializer,
7583 {
7584 use serde::ser::SerializeStruct;
7585 let mut len = 0;
7586 if self.task_id.is_some() {
7587 len += 1;
7588 }
7589 if self.output_id != 0 {
7590 len += 1;
7591 }
7592 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskOutputId", len)?;
7593 if let Some(v) = self.task_id.as_ref() {
7594 struct_ser.serialize_field("taskId", v)?;
7595 }
7596 if self.output_id != 0 {
7597 #[allow(clippy::needless_borrow)]
7598 #[allow(clippy::needless_borrows_for_generic_args)]
7599 struct_ser.serialize_field("outputId", ToString::to_string(&self.output_id).as_str())?;
7600 }
7601 struct_ser.end()
7602 }
7603}
7604impl<'de> serde::Deserialize<'de> for TaskOutputId {
7605 #[allow(deprecated)]
7606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7607 where
7608 D: serde::Deserializer<'de>,
7609 {
7610 const FIELDS: &[&str] = &[
7611 "task_id",
7612 "taskId",
7613 "output_id",
7614 "outputId",
7615 ];
7616
7617 #[allow(clippy::enum_variant_names)]
7618 enum GeneratedField {
7619 TaskId,
7620 OutputId,
7621 }
7622 impl<'de> serde::Deserialize<'de> for GeneratedField {
7623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7624 where
7625 D: serde::Deserializer<'de>,
7626 {
7627 struct GeneratedVisitor;
7628
7629 impl serde::de::Visitor<'_> for GeneratedVisitor {
7630 type Value = GeneratedField;
7631
7632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7633 write!(formatter, "expected one of: {:?}", &FIELDS)
7634 }
7635
7636 #[allow(unused_variables)]
7637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7638 where
7639 E: serde::de::Error,
7640 {
7641 match value {
7642 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7643 "outputId" | "output_id" => Ok(GeneratedField::OutputId),
7644 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7645 }
7646 }
7647 }
7648 deserializer.deserialize_identifier(GeneratedVisitor)
7649 }
7650 }
7651 struct GeneratedVisitor;
7652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7653 type Value = TaskOutputId;
7654
7655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7656 formatter.write_str("struct batch_plan.TaskOutputId")
7657 }
7658
7659 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskOutputId, V::Error>
7660 where
7661 V: serde::de::MapAccess<'de>,
7662 {
7663 let mut task_id__ = None;
7664 let mut output_id__ = None;
7665 while let Some(k) = map_.next_key()? {
7666 match k {
7667 GeneratedField::TaskId => {
7668 if task_id__.is_some() {
7669 return Err(serde::de::Error::duplicate_field("taskId"));
7670 }
7671 task_id__ = map_.next_value()?;
7672 }
7673 GeneratedField::OutputId => {
7674 if output_id__.is_some() {
7675 return Err(serde::de::Error::duplicate_field("outputId"));
7676 }
7677 output_id__ =
7678 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7679 ;
7680 }
7681 }
7682 }
7683 Ok(TaskOutputId {
7684 task_id: task_id__,
7685 output_id: output_id__.unwrap_or_default(),
7686 })
7687 }
7688 }
7689 deserializer.deserialize_struct("batch_plan.TaskOutputId", FIELDS, GeneratedVisitor)
7690 }
7691}
7692impl serde::Serialize for TopNNode {
7693 #[allow(deprecated)]
7694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7695 where
7696 S: serde::Serializer,
7697 {
7698 use serde::ser::SerializeStruct;
7699 let mut len = 0;
7700 if !self.column_orders.is_empty() {
7701 len += 1;
7702 }
7703 if self.limit != 0 {
7704 len += 1;
7705 }
7706 if self.offset != 0 {
7707 len += 1;
7708 }
7709 if self.with_ties {
7710 len += 1;
7711 }
7712 let mut struct_ser = serializer.serialize_struct("batch_plan.TopNNode", len)?;
7713 if !self.column_orders.is_empty() {
7714 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7715 }
7716 if self.limit != 0 {
7717 #[allow(clippy::needless_borrow)]
7718 #[allow(clippy::needless_borrows_for_generic_args)]
7719 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
7720 }
7721 if self.offset != 0 {
7722 #[allow(clippy::needless_borrow)]
7723 #[allow(clippy::needless_borrows_for_generic_args)]
7724 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
7725 }
7726 if self.with_ties {
7727 struct_ser.serialize_field("withTies", &self.with_ties)?;
7728 }
7729 struct_ser.end()
7730 }
7731}
7732impl<'de> serde::Deserialize<'de> for TopNNode {
7733 #[allow(deprecated)]
7734 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7735 where
7736 D: serde::Deserializer<'de>,
7737 {
7738 const FIELDS: &[&str] = &[
7739 "column_orders",
7740 "columnOrders",
7741 "limit",
7742 "offset",
7743 "with_ties",
7744 "withTies",
7745 ];
7746
7747 #[allow(clippy::enum_variant_names)]
7748 enum GeneratedField {
7749 ColumnOrders,
7750 Limit,
7751 Offset,
7752 WithTies,
7753 }
7754 impl<'de> serde::Deserialize<'de> for GeneratedField {
7755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7756 where
7757 D: serde::Deserializer<'de>,
7758 {
7759 struct GeneratedVisitor;
7760
7761 impl serde::de::Visitor<'_> for GeneratedVisitor {
7762 type Value = GeneratedField;
7763
7764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7765 write!(formatter, "expected one of: {:?}", &FIELDS)
7766 }
7767
7768 #[allow(unused_variables)]
7769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7770 where
7771 E: serde::de::Error,
7772 {
7773 match value {
7774 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7775 "limit" => Ok(GeneratedField::Limit),
7776 "offset" => Ok(GeneratedField::Offset),
7777 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
7778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7779 }
7780 }
7781 }
7782 deserializer.deserialize_identifier(GeneratedVisitor)
7783 }
7784 }
7785 struct GeneratedVisitor;
7786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7787 type Value = TopNNode;
7788
7789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7790 formatter.write_str("struct batch_plan.TopNNode")
7791 }
7792
7793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
7794 where
7795 V: serde::de::MapAccess<'de>,
7796 {
7797 let mut column_orders__ = None;
7798 let mut limit__ = None;
7799 let mut offset__ = None;
7800 let mut with_ties__ = None;
7801 while let Some(k) = map_.next_key()? {
7802 match k {
7803 GeneratedField::ColumnOrders => {
7804 if column_orders__.is_some() {
7805 return Err(serde::de::Error::duplicate_field("columnOrders"));
7806 }
7807 column_orders__ = Some(map_.next_value()?);
7808 }
7809 GeneratedField::Limit => {
7810 if limit__.is_some() {
7811 return Err(serde::de::Error::duplicate_field("limit"));
7812 }
7813 limit__ =
7814 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7815 ;
7816 }
7817 GeneratedField::Offset => {
7818 if offset__.is_some() {
7819 return Err(serde::de::Error::duplicate_field("offset"));
7820 }
7821 offset__ =
7822 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7823 ;
7824 }
7825 GeneratedField::WithTies => {
7826 if with_ties__.is_some() {
7827 return Err(serde::de::Error::duplicate_field("withTies"));
7828 }
7829 with_ties__ = Some(map_.next_value()?);
7830 }
7831 }
7832 }
7833 Ok(TopNNode {
7834 column_orders: column_orders__.unwrap_or_default(),
7835 limit: limit__.unwrap_or_default(),
7836 offset: offset__.unwrap_or_default(),
7837 with_ties: with_ties__.unwrap_or_default(),
7838 })
7839 }
7840 }
7841 deserializer.deserialize_struct("batch_plan.TopNNode", FIELDS, GeneratedVisitor)
7842 }
7843}
7844impl serde::Serialize for UnionNode {
7845 #[allow(deprecated)]
7846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7847 where
7848 S: serde::Serializer,
7849 {
7850 use serde::ser::SerializeStruct;
7851 let len = 0;
7852 let struct_ser = serializer.serialize_struct("batch_plan.UnionNode", len)?;
7853 struct_ser.end()
7854 }
7855}
7856impl<'de> serde::Deserialize<'de> for UnionNode {
7857 #[allow(deprecated)]
7858 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7859 where
7860 D: serde::Deserializer<'de>,
7861 {
7862 const FIELDS: &[&str] = &[
7863 ];
7864
7865 #[allow(clippy::enum_variant_names)]
7866 enum GeneratedField {
7867 }
7868 impl<'de> serde::Deserialize<'de> for GeneratedField {
7869 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7870 where
7871 D: serde::Deserializer<'de>,
7872 {
7873 struct GeneratedVisitor;
7874
7875 impl serde::de::Visitor<'_> for GeneratedVisitor {
7876 type Value = GeneratedField;
7877
7878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7879 write!(formatter, "expected one of: {:?}", &FIELDS)
7880 }
7881
7882 #[allow(unused_variables)]
7883 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7884 where
7885 E: serde::de::Error,
7886 {
7887 Err(serde::de::Error::unknown_field(value, FIELDS))
7888 }
7889 }
7890 deserializer.deserialize_identifier(GeneratedVisitor)
7891 }
7892 }
7893 struct GeneratedVisitor;
7894 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7895 type Value = UnionNode;
7896
7897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7898 formatter.write_str("struct batch_plan.UnionNode")
7899 }
7900
7901 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
7902 where
7903 V: serde::de::MapAccess<'de>,
7904 {
7905 while map_.next_key::<GeneratedField>()?.is_some() {
7906 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7907 }
7908 Ok(UnionNode {
7909 })
7910 }
7911 }
7912 deserializer.deserialize_struct("batch_plan.UnionNode", FIELDS, GeneratedVisitor)
7913 }
7914}
7915impl serde::Serialize for UpdateNode {
7916 #[allow(deprecated)]
7917 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7918 where
7919 S: serde::Serializer,
7920 {
7921 use serde::ser::SerializeStruct;
7922 let mut len = 0;
7923 if self.table_id != 0 {
7924 len += 1;
7925 }
7926 if self.table_version_id != 0 {
7927 len += 1;
7928 }
7929 if !self.old_exprs.is_empty() {
7930 len += 1;
7931 }
7932 if !self.new_exprs.is_empty() {
7933 len += 1;
7934 }
7935 if self.returning {
7936 len += 1;
7937 }
7938 if self.upsert {
7939 len += 1;
7940 }
7941 if self.session_id != 0 {
7942 len += 1;
7943 }
7944 let mut struct_ser = serializer.serialize_struct("batch_plan.UpdateNode", len)?;
7945 if self.table_id != 0 {
7946 struct_ser.serialize_field("tableId", &self.table_id)?;
7947 }
7948 if self.table_version_id != 0 {
7949 #[allow(clippy::needless_borrow)]
7950 #[allow(clippy::needless_borrows_for_generic_args)]
7951 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
7952 }
7953 if !self.old_exprs.is_empty() {
7954 struct_ser.serialize_field("oldExprs", &self.old_exprs)?;
7955 }
7956 if !self.new_exprs.is_empty() {
7957 struct_ser.serialize_field("newExprs", &self.new_exprs)?;
7958 }
7959 if self.returning {
7960 struct_ser.serialize_field("returning", &self.returning)?;
7961 }
7962 if self.upsert {
7963 struct_ser.serialize_field("upsert", &self.upsert)?;
7964 }
7965 if self.session_id != 0 {
7966 struct_ser.serialize_field("sessionId", &self.session_id)?;
7967 }
7968 struct_ser.end()
7969 }
7970}
7971impl<'de> serde::Deserialize<'de> for UpdateNode {
7972 #[allow(deprecated)]
7973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7974 where
7975 D: serde::Deserializer<'de>,
7976 {
7977 const FIELDS: &[&str] = &[
7978 "table_id",
7979 "tableId",
7980 "table_version_id",
7981 "tableVersionId",
7982 "old_exprs",
7983 "oldExprs",
7984 "new_exprs",
7985 "newExprs",
7986 "returning",
7987 "upsert",
7988 "session_id",
7989 "sessionId",
7990 ];
7991
7992 #[allow(clippy::enum_variant_names)]
7993 enum GeneratedField {
7994 TableId,
7995 TableVersionId,
7996 OldExprs,
7997 NewExprs,
7998 Returning,
7999 Upsert,
8000 SessionId,
8001 }
8002 impl<'de> serde::Deserialize<'de> for GeneratedField {
8003 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8004 where
8005 D: serde::Deserializer<'de>,
8006 {
8007 struct GeneratedVisitor;
8008
8009 impl serde::de::Visitor<'_> for GeneratedVisitor {
8010 type Value = GeneratedField;
8011
8012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8013 write!(formatter, "expected one of: {:?}", &FIELDS)
8014 }
8015
8016 #[allow(unused_variables)]
8017 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8018 where
8019 E: serde::de::Error,
8020 {
8021 match value {
8022 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8023 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
8024 "oldExprs" | "old_exprs" => Ok(GeneratedField::OldExprs),
8025 "newExprs" | "new_exprs" => Ok(GeneratedField::NewExprs),
8026 "returning" => Ok(GeneratedField::Returning),
8027 "upsert" => Ok(GeneratedField::Upsert),
8028 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
8029 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8030 }
8031 }
8032 }
8033 deserializer.deserialize_identifier(GeneratedVisitor)
8034 }
8035 }
8036 struct GeneratedVisitor;
8037 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8038 type Value = UpdateNode;
8039
8040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8041 formatter.write_str("struct batch_plan.UpdateNode")
8042 }
8043
8044 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateNode, V::Error>
8045 where
8046 V: serde::de::MapAccess<'de>,
8047 {
8048 let mut table_id__ = None;
8049 let mut table_version_id__ = None;
8050 let mut old_exprs__ = None;
8051 let mut new_exprs__ = None;
8052 let mut returning__ = None;
8053 let mut upsert__ = None;
8054 let mut session_id__ = None;
8055 while let Some(k) = map_.next_key()? {
8056 match k {
8057 GeneratedField::TableId => {
8058 if table_id__.is_some() {
8059 return Err(serde::de::Error::duplicate_field("tableId"));
8060 }
8061 table_id__ =
8062 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8063 ;
8064 }
8065 GeneratedField::TableVersionId => {
8066 if table_version_id__.is_some() {
8067 return Err(serde::de::Error::duplicate_field("tableVersionId"));
8068 }
8069 table_version_id__ =
8070 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8071 ;
8072 }
8073 GeneratedField::OldExprs => {
8074 if old_exprs__.is_some() {
8075 return Err(serde::de::Error::duplicate_field("oldExprs"));
8076 }
8077 old_exprs__ = Some(map_.next_value()?);
8078 }
8079 GeneratedField::NewExprs => {
8080 if new_exprs__.is_some() {
8081 return Err(serde::de::Error::duplicate_field("newExprs"));
8082 }
8083 new_exprs__ = Some(map_.next_value()?);
8084 }
8085 GeneratedField::Returning => {
8086 if returning__.is_some() {
8087 return Err(serde::de::Error::duplicate_field("returning"));
8088 }
8089 returning__ = Some(map_.next_value()?);
8090 }
8091 GeneratedField::Upsert => {
8092 if upsert__.is_some() {
8093 return Err(serde::de::Error::duplicate_field("upsert"));
8094 }
8095 upsert__ = Some(map_.next_value()?);
8096 }
8097 GeneratedField::SessionId => {
8098 if session_id__.is_some() {
8099 return Err(serde::de::Error::duplicate_field("sessionId"));
8100 }
8101 session_id__ =
8102 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8103 ;
8104 }
8105 }
8106 }
8107 Ok(UpdateNode {
8108 table_id: table_id__.unwrap_or_default(),
8109 table_version_id: table_version_id__.unwrap_or_default(),
8110 old_exprs: old_exprs__.unwrap_or_default(),
8111 new_exprs: new_exprs__.unwrap_or_default(),
8112 returning: returning__.unwrap_or_default(),
8113 upsert: upsert__.unwrap_or_default(),
8114 session_id: session_id__.unwrap_or_default(),
8115 })
8116 }
8117 }
8118 deserializer.deserialize_struct("batch_plan.UpdateNode", FIELDS, GeneratedVisitor)
8119 }
8120}
8121impl serde::Serialize for ValuesNode {
8122 #[allow(deprecated)]
8123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8124 where
8125 S: serde::Serializer,
8126 {
8127 use serde::ser::SerializeStruct;
8128 let mut len = 0;
8129 if !self.tuples.is_empty() {
8130 len += 1;
8131 }
8132 if !self.fields.is_empty() {
8133 len += 1;
8134 }
8135 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode", len)?;
8136 if !self.tuples.is_empty() {
8137 struct_ser.serialize_field("tuples", &self.tuples)?;
8138 }
8139 if !self.fields.is_empty() {
8140 struct_ser.serialize_field("fields", &self.fields)?;
8141 }
8142 struct_ser.end()
8143 }
8144}
8145impl<'de> serde::Deserialize<'de> for ValuesNode {
8146 #[allow(deprecated)]
8147 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8148 where
8149 D: serde::Deserializer<'de>,
8150 {
8151 const FIELDS: &[&str] = &[
8152 "tuples",
8153 "fields",
8154 ];
8155
8156 #[allow(clippy::enum_variant_names)]
8157 enum GeneratedField {
8158 Tuples,
8159 Fields,
8160 }
8161 impl<'de> serde::Deserialize<'de> for GeneratedField {
8162 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8163 where
8164 D: serde::Deserializer<'de>,
8165 {
8166 struct GeneratedVisitor;
8167
8168 impl serde::de::Visitor<'_> for GeneratedVisitor {
8169 type Value = GeneratedField;
8170
8171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8172 write!(formatter, "expected one of: {:?}", &FIELDS)
8173 }
8174
8175 #[allow(unused_variables)]
8176 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8177 where
8178 E: serde::de::Error,
8179 {
8180 match value {
8181 "tuples" => Ok(GeneratedField::Tuples),
8182 "fields" => Ok(GeneratedField::Fields),
8183 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8184 }
8185 }
8186 }
8187 deserializer.deserialize_identifier(GeneratedVisitor)
8188 }
8189 }
8190 struct GeneratedVisitor;
8191 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8192 type Value = ValuesNode;
8193
8194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8195 formatter.write_str("struct batch_plan.ValuesNode")
8196 }
8197
8198 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
8199 where
8200 V: serde::de::MapAccess<'de>,
8201 {
8202 let mut tuples__ = None;
8203 let mut fields__ = None;
8204 while let Some(k) = map_.next_key()? {
8205 match k {
8206 GeneratedField::Tuples => {
8207 if tuples__.is_some() {
8208 return Err(serde::de::Error::duplicate_field("tuples"));
8209 }
8210 tuples__ = Some(map_.next_value()?);
8211 }
8212 GeneratedField::Fields => {
8213 if fields__.is_some() {
8214 return Err(serde::de::Error::duplicate_field("fields"));
8215 }
8216 fields__ = Some(map_.next_value()?);
8217 }
8218 }
8219 }
8220 Ok(ValuesNode {
8221 tuples: tuples__.unwrap_or_default(),
8222 fields: fields__.unwrap_or_default(),
8223 })
8224 }
8225 }
8226 deserializer.deserialize_struct("batch_plan.ValuesNode", FIELDS, GeneratedVisitor)
8227 }
8228}
8229impl serde::Serialize for values_node::ExprTuple {
8230 #[allow(deprecated)]
8231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8232 where
8233 S: serde::Serializer,
8234 {
8235 use serde::ser::SerializeStruct;
8236 let mut len = 0;
8237 if !self.cells.is_empty() {
8238 len += 1;
8239 }
8240 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode.ExprTuple", len)?;
8241 if !self.cells.is_empty() {
8242 struct_ser.serialize_field("cells", &self.cells)?;
8243 }
8244 struct_ser.end()
8245 }
8246}
8247impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
8248 #[allow(deprecated)]
8249 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8250 where
8251 D: serde::Deserializer<'de>,
8252 {
8253 const FIELDS: &[&str] = &[
8254 "cells",
8255 ];
8256
8257 #[allow(clippy::enum_variant_names)]
8258 enum GeneratedField {
8259 Cells,
8260 }
8261 impl<'de> serde::Deserialize<'de> for GeneratedField {
8262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8263 where
8264 D: serde::Deserializer<'de>,
8265 {
8266 struct GeneratedVisitor;
8267
8268 impl serde::de::Visitor<'_> for GeneratedVisitor {
8269 type Value = GeneratedField;
8270
8271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8272 write!(formatter, "expected one of: {:?}", &FIELDS)
8273 }
8274
8275 #[allow(unused_variables)]
8276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8277 where
8278 E: serde::de::Error,
8279 {
8280 match value {
8281 "cells" => Ok(GeneratedField::Cells),
8282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8283 }
8284 }
8285 }
8286 deserializer.deserialize_identifier(GeneratedVisitor)
8287 }
8288 }
8289 struct GeneratedVisitor;
8290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8291 type Value = values_node::ExprTuple;
8292
8293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8294 formatter.write_str("struct batch_plan.ValuesNode.ExprTuple")
8295 }
8296
8297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
8298 where
8299 V: serde::de::MapAccess<'de>,
8300 {
8301 let mut cells__ = None;
8302 while let Some(k) = map_.next_key()? {
8303 match k {
8304 GeneratedField::Cells => {
8305 if cells__.is_some() {
8306 return Err(serde::de::Error::duplicate_field("cells"));
8307 }
8308 cells__ = Some(map_.next_value()?);
8309 }
8310 }
8311 }
8312 Ok(values_node::ExprTuple {
8313 cells: cells__.unwrap_or_default(),
8314 })
8315 }
8316 }
8317 deserializer.deserialize_struct("batch_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
8318 }
8319}
8320impl serde::Serialize for VectorIndexNearestNode {
8321 #[allow(deprecated)]
8322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8323 where
8324 S: serde::Serializer,
8325 {
8326 use serde::ser::SerializeStruct;
8327 let mut len = 0;
8328 if self.reader_desc.is_some() {
8329 len += 1;
8330 }
8331 if self.vector_column_idx != 0 {
8332 len += 1;
8333 }
8334 if self.query_epoch.is_some() {
8335 len += 1;
8336 }
8337 let mut struct_ser = serializer.serialize_struct("batch_plan.VectorIndexNearestNode", len)?;
8338 if let Some(v) = self.reader_desc.as_ref() {
8339 struct_ser.serialize_field("readerDesc", v)?;
8340 }
8341 if self.vector_column_idx != 0 {
8342 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
8343 }
8344 if let Some(v) = self.query_epoch.as_ref() {
8345 struct_ser.serialize_field("queryEpoch", v)?;
8346 }
8347 struct_ser.end()
8348 }
8349}
8350impl<'de> serde::Deserialize<'de> for VectorIndexNearestNode {
8351 #[allow(deprecated)]
8352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8353 where
8354 D: serde::Deserializer<'de>,
8355 {
8356 const FIELDS: &[&str] = &[
8357 "reader_desc",
8358 "readerDesc",
8359 "vector_column_idx",
8360 "vectorColumnIdx",
8361 "query_epoch",
8362 "queryEpoch",
8363 ];
8364
8365 #[allow(clippy::enum_variant_names)]
8366 enum GeneratedField {
8367 ReaderDesc,
8368 VectorColumnIdx,
8369 QueryEpoch,
8370 }
8371 impl<'de> serde::Deserialize<'de> for GeneratedField {
8372 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8373 where
8374 D: serde::Deserializer<'de>,
8375 {
8376 struct GeneratedVisitor;
8377
8378 impl serde::de::Visitor<'_> for GeneratedVisitor {
8379 type Value = GeneratedField;
8380
8381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8382 write!(formatter, "expected one of: {:?}", &FIELDS)
8383 }
8384
8385 #[allow(unused_variables)]
8386 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8387 where
8388 E: serde::de::Error,
8389 {
8390 match value {
8391 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
8392 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
8393 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
8394 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8395 }
8396 }
8397 }
8398 deserializer.deserialize_identifier(GeneratedVisitor)
8399 }
8400 }
8401 struct GeneratedVisitor;
8402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8403 type Value = VectorIndexNearestNode;
8404
8405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8406 formatter.write_str("struct batch_plan.VectorIndexNearestNode")
8407 }
8408
8409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexNearestNode, V::Error>
8410 where
8411 V: serde::de::MapAccess<'de>,
8412 {
8413 let mut reader_desc__ = None;
8414 let mut vector_column_idx__ = None;
8415 let mut query_epoch__ = None;
8416 while let Some(k) = map_.next_key()? {
8417 match k {
8418 GeneratedField::ReaderDesc => {
8419 if reader_desc__.is_some() {
8420 return Err(serde::de::Error::duplicate_field("readerDesc"));
8421 }
8422 reader_desc__ = map_.next_value()?;
8423 }
8424 GeneratedField::VectorColumnIdx => {
8425 if vector_column_idx__.is_some() {
8426 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
8427 }
8428 vector_column_idx__ =
8429 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8430 ;
8431 }
8432 GeneratedField::QueryEpoch => {
8433 if query_epoch__.is_some() {
8434 return Err(serde::de::Error::duplicate_field("queryEpoch"));
8435 }
8436 query_epoch__ = map_.next_value()?;
8437 }
8438 }
8439 }
8440 Ok(VectorIndexNearestNode {
8441 reader_desc: reader_desc__,
8442 vector_column_idx: vector_column_idx__.unwrap_or_default(),
8443 query_epoch: query_epoch__,
8444 })
8445 }
8446 }
8447 deserializer.deserialize_struct("batch_plan.VectorIndexNearestNode", FIELDS, GeneratedVisitor)
8448 }
8449}