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