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