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 IcebergMetadataScanNode {
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.with_properties.is_empty() {
3230 len += 1;
3231 }
3232 if !self.secret_refs.is_empty() {
3233 len += 1;
3234 }
3235 if self.metadata_type != 0 {
3236 len += 1;
3237 }
3238 if self.time_travel.is_some() {
3239 len += 1;
3240 }
3241 let mut struct_ser = serializer.serialize_struct("batch_plan.IcebergMetadataScanNode", len)?;
3242 if !self.with_properties.is_empty() {
3243 struct_ser.serialize_field("withProperties", &self.with_properties)?;
3244 }
3245 if !self.secret_refs.is_empty() {
3246 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3247 }
3248 if self.metadata_type != 0 {
3249 let v = iceberg_metadata_scan_node::MetadataType::try_from(self.metadata_type)
3250 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.metadata_type)))?;
3251 struct_ser.serialize_field("metadataType", &v)?;
3252 }
3253 if let Some(v) = self.time_travel.as_ref() {
3254 match v {
3255 iceberg_metadata_scan_node::TimeTravel::SnapshotId(v) => {
3256 #[allow(clippy::needless_borrow)]
3257 #[allow(clippy::needless_borrows_for_generic_args)]
3258 struct_ser.serialize_field("snapshotId", ToString::to_string(&v).as_str())?;
3259 }
3260 iceberg_metadata_scan_node::TimeTravel::TimestampMs(v) => {
3261 #[allow(clippy::needless_borrow)]
3262 #[allow(clippy::needless_borrows_for_generic_args)]
3263 struct_ser.serialize_field("timestampMs", ToString::to_string(&v).as_str())?;
3264 }
3265 }
3266 }
3267 struct_ser.end()
3268 }
3269}
3270impl<'de> serde::Deserialize<'de> for IcebergMetadataScanNode {
3271 #[allow(deprecated)]
3272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3273 where
3274 D: serde::Deserializer<'de>,
3275 {
3276 const FIELDS: &[&str] = &[
3277 "with_properties",
3278 "withProperties",
3279 "secret_refs",
3280 "secretRefs",
3281 "metadata_type",
3282 "metadataType",
3283 "snapshot_id",
3284 "snapshotId",
3285 "timestamp_ms",
3286 "timestampMs",
3287 ];
3288
3289 #[allow(clippy::enum_variant_names)]
3290 enum GeneratedField {
3291 WithProperties,
3292 SecretRefs,
3293 MetadataType,
3294 SnapshotId,
3295 TimestampMs,
3296 }
3297 impl<'de> serde::Deserialize<'de> for GeneratedField {
3298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3299 where
3300 D: serde::Deserializer<'de>,
3301 {
3302 struct GeneratedVisitor;
3303
3304 impl serde::de::Visitor<'_> for GeneratedVisitor {
3305 type Value = GeneratedField;
3306
3307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3308 write!(formatter, "expected one of: {:?}", &FIELDS)
3309 }
3310
3311 #[allow(unused_variables)]
3312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3313 where
3314 E: serde::de::Error,
3315 {
3316 match value {
3317 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
3318 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3319 "metadataType" | "metadata_type" => Ok(GeneratedField::MetadataType),
3320 "snapshotId" | "snapshot_id" => Ok(GeneratedField::SnapshotId),
3321 "timestampMs" | "timestamp_ms" => Ok(GeneratedField::TimestampMs),
3322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3323 }
3324 }
3325 }
3326 deserializer.deserialize_identifier(GeneratedVisitor)
3327 }
3328 }
3329 struct GeneratedVisitor;
3330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3331 type Value = IcebergMetadataScanNode;
3332
3333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3334 formatter.write_str("struct batch_plan.IcebergMetadataScanNode")
3335 }
3336
3337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergMetadataScanNode, V::Error>
3338 where
3339 V: serde::de::MapAccess<'de>,
3340 {
3341 let mut with_properties__ = None;
3342 let mut secret_refs__ = None;
3343 let mut metadata_type__ = None;
3344 let mut time_travel__ = None;
3345 while let Some(k) = map_.next_key()? {
3346 match k {
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::SecretRefs => {
3356 if secret_refs__.is_some() {
3357 return Err(serde::de::Error::duplicate_field("secretRefs"));
3358 }
3359 secret_refs__ = Some(
3360 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3361 );
3362 }
3363 GeneratedField::MetadataType => {
3364 if metadata_type__.is_some() {
3365 return Err(serde::de::Error::duplicate_field("metadataType"));
3366 }
3367 metadata_type__ = Some(map_.next_value::<iceberg_metadata_scan_node::MetadataType>()? as i32);
3368 }
3369 GeneratedField::SnapshotId => {
3370 if time_travel__.is_some() {
3371 return Err(serde::de::Error::duplicate_field("snapshotId"));
3372 }
3373 time_travel__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| iceberg_metadata_scan_node::TimeTravel::SnapshotId(x.0));
3374 }
3375 GeneratedField::TimestampMs => {
3376 if time_travel__.is_some() {
3377 return Err(serde::de::Error::duplicate_field("timestampMs"));
3378 }
3379 time_travel__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| iceberg_metadata_scan_node::TimeTravel::TimestampMs(x.0));
3380 }
3381 }
3382 }
3383 Ok(IcebergMetadataScanNode {
3384 with_properties: with_properties__.unwrap_or_default(),
3385 secret_refs: secret_refs__.unwrap_or_default(),
3386 metadata_type: metadata_type__.unwrap_or_default(),
3387 time_travel: time_travel__,
3388 })
3389 }
3390 }
3391 deserializer.deserialize_struct("batch_plan.IcebergMetadataScanNode", FIELDS, GeneratedVisitor)
3392 }
3393}
3394impl serde::Serialize for iceberg_metadata_scan_node::MetadataType {
3395 #[allow(deprecated)]
3396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3397 where
3398 S: serde::Serializer,
3399 {
3400 let variant = match self {
3401 Self::Unspecified => "METADATA_TYPE_UNSPECIFIED",
3402 Self::Snapshots => "METADATA_TYPE_SNAPSHOTS",
3403 Self::Manifests => "METADATA_TYPE_MANIFESTS",
3404 Self::Files => "METADATA_TYPE_FILES",
3405 };
3406 serializer.serialize_str(variant)
3407 }
3408}
3409impl<'de> serde::Deserialize<'de> for iceberg_metadata_scan_node::MetadataType {
3410 #[allow(deprecated)]
3411 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3412 where
3413 D: serde::Deserializer<'de>,
3414 {
3415 const FIELDS: &[&str] = &[
3416 "METADATA_TYPE_UNSPECIFIED",
3417 "METADATA_TYPE_SNAPSHOTS",
3418 "METADATA_TYPE_MANIFESTS",
3419 "METADATA_TYPE_FILES",
3420 ];
3421
3422 struct GeneratedVisitor;
3423
3424 impl serde::de::Visitor<'_> for GeneratedVisitor {
3425 type Value = iceberg_metadata_scan_node::MetadataType;
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 "METADATA_TYPE_UNSPECIFIED" => Ok(iceberg_metadata_scan_node::MetadataType::Unspecified),
3461 "METADATA_TYPE_SNAPSHOTS" => Ok(iceberg_metadata_scan_node::MetadataType::Snapshots),
3462 "METADATA_TYPE_MANIFESTS" => Ok(iceberg_metadata_scan_node::MetadataType::Manifests),
3463 "METADATA_TYPE_FILES" => Ok(iceberg_metadata_scan_node::MetadataType::Files),
3464 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3465 }
3466 }
3467 }
3468 deserializer.deserialize_any(GeneratedVisitor)
3469 }
3470}
3471impl serde::Serialize for IcebergScanNode {
3472 #[allow(deprecated)]
3473 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3474 where
3475 S: serde::Serializer,
3476 {
3477 use serde::ser::SerializeStruct;
3478 let mut len = 0;
3479 if !self.columns.is_empty() {
3480 len += 1;
3481 }
3482 if !self.with_properties.is_empty() {
3483 len += 1;
3484 }
3485 if !self.split.is_empty() {
3486 len += 1;
3487 }
3488 if !self.secret_refs.is_empty() {
3489 len += 1;
3490 }
3491 if self.iceberg_scan_type != 0 {
3492 len += 1;
3493 }
3494 let mut struct_ser = serializer.serialize_struct("batch_plan.IcebergScanNode", len)?;
3495 if !self.columns.is_empty() {
3496 struct_ser.serialize_field("columns", &self.columns)?;
3497 }
3498 if !self.with_properties.is_empty() {
3499 struct_ser.serialize_field("withProperties", &self.with_properties)?;
3500 }
3501 if !self.split.is_empty() {
3502 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
3503 }
3504 if !self.secret_refs.is_empty() {
3505 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3506 }
3507 if self.iceberg_scan_type != 0 {
3508 let v = iceberg_scan_node::IcebergScanType::try_from(self.iceberg_scan_type)
3509 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.iceberg_scan_type)))?;
3510 struct_ser.serialize_field("icebergScanType", &v)?;
3511 }
3512 struct_ser.end()
3513 }
3514}
3515impl<'de> serde::Deserialize<'de> for IcebergScanNode {
3516 #[allow(deprecated)]
3517 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3518 where
3519 D: serde::Deserializer<'de>,
3520 {
3521 const FIELDS: &[&str] = &[
3522 "columns",
3523 "with_properties",
3524 "withProperties",
3525 "split",
3526 "secret_refs",
3527 "secretRefs",
3528 "iceberg_scan_type",
3529 "icebergScanType",
3530 ];
3531
3532 #[allow(clippy::enum_variant_names)]
3533 enum GeneratedField {
3534 Columns,
3535 WithProperties,
3536 Split,
3537 SecretRefs,
3538 IcebergScanType,
3539 }
3540 impl<'de> serde::Deserialize<'de> for GeneratedField {
3541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3542 where
3543 D: serde::Deserializer<'de>,
3544 {
3545 struct GeneratedVisitor;
3546
3547 impl serde::de::Visitor<'_> for GeneratedVisitor {
3548 type Value = GeneratedField;
3549
3550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3551 write!(formatter, "expected one of: {:?}", &FIELDS)
3552 }
3553
3554 #[allow(unused_variables)]
3555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3556 where
3557 E: serde::de::Error,
3558 {
3559 match value {
3560 "columns" => Ok(GeneratedField::Columns),
3561 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
3562 "split" => Ok(GeneratedField::Split),
3563 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3564 "icebergScanType" | "iceberg_scan_type" => Ok(GeneratedField::IcebergScanType),
3565 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3566 }
3567 }
3568 }
3569 deserializer.deserialize_identifier(GeneratedVisitor)
3570 }
3571 }
3572 struct GeneratedVisitor;
3573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3574 type Value = IcebergScanNode;
3575
3576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3577 formatter.write_str("struct batch_plan.IcebergScanNode")
3578 }
3579
3580 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergScanNode, V::Error>
3581 where
3582 V: serde::de::MapAccess<'de>,
3583 {
3584 let mut columns__ = None;
3585 let mut with_properties__ = None;
3586 let mut split__ = None;
3587 let mut secret_refs__ = None;
3588 let mut iceberg_scan_type__ = None;
3589 while let Some(k) = map_.next_key()? {
3590 match k {
3591 GeneratedField::Columns => {
3592 if columns__.is_some() {
3593 return Err(serde::de::Error::duplicate_field("columns"));
3594 }
3595 columns__ = Some(map_.next_value()?);
3596 }
3597 GeneratedField::WithProperties => {
3598 if with_properties__.is_some() {
3599 return Err(serde::de::Error::duplicate_field("withProperties"));
3600 }
3601 with_properties__ = Some(
3602 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3603 );
3604 }
3605 GeneratedField::Split => {
3606 if split__.is_some() {
3607 return Err(serde::de::Error::duplicate_field("split"));
3608 }
3609 split__ =
3610 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
3611 .into_iter().map(|x| x.0).collect())
3612 ;
3613 }
3614 GeneratedField::SecretRefs => {
3615 if secret_refs__.is_some() {
3616 return Err(serde::de::Error::duplicate_field("secretRefs"));
3617 }
3618 secret_refs__ = Some(
3619 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3620 );
3621 }
3622 GeneratedField::IcebergScanType => {
3623 if iceberg_scan_type__.is_some() {
3624 return Err(serde::de::Error::duplicate_field("icebergScanType"));
3625 }
3626 iceberg_scan_type__ = Some(map_.next_value::<iceberg_scan_node::IcebergScanType>()? as i32);
3627 }
3628 }
3629 }
3630 Ok(IcebergScanNode {
3631 columns: columns__.unwrap_or_default(),
3632 with_properties: with_properties__.unwrap_or_default(),
3633 split: split__.unwrap_or_default(),
3634 secret_refs: secret_refs__.unwrap_or_default(),
3635 iceberg_scan_type: iceberg_scan_type__.unwrap_or_default(),
3636 })
3637 }
3638 }
3639 deserializer.deserialize_struct("batch_plan.IcebergScanNode", FIELDS, GeneratedVisitor)
3640 }
3641}
3642impl serde::Serialize for iceberg_scan_node::IcebergScanType {
3643 #[allow(deprecated)]
3644 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3645 where
3646 S: serde::Serializer,
3647 {
3648 let variant = match self {
3649 Self::Unspecified => "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3650 Self::DataScan => "ICEBERG_SCAN_TYPE_DATA_SCAN",
3651 Self::EqualityDeleteScan => "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3652 Self::PositionDeleteScan => "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3653 Self::CountStar => "ICEBERG_SCAN_TYPE_COUNT_STAR",
3654 };
3655 serializer.serialize_str(variant)
3656 }
3657}
3658impl<'de> serde::Deserialize<'de> for iceberg_scan_node::IcebergScanType {
3659 #[allow(deprecated)]
3660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3661 where
3662 D: serde::Deserializer<'de>,
3663 {
3664 const FIELDS: &[&str] = &[
3665 "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3666 "ICEBERG_SCAN_TYPE_DATA_SCAN",
3667 "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3668 "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3669 "ICEBERG_SCAN_TYPE_COUNT_STAR",
3670 ];
3671
3672 struct GeneratedVisitor;
3673
3674 impl serde::de::Visitor<'_> for GeneratedVisitor {
3675 type Value = iceberg_scan_node::IcebergScanType;
3676
3677 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3678 write!(formatter, "expected one of: {:?}", &FIELDS)
3679 }
3680
3681 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3682 where
3683 E: serde::de::Error,
3684 {
3685 i32::try_from(v)
3686 .ok()
3687 .and_then(|x| x.try_into().ok())
3688 .ok_or_else(|| {
3689 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3690 })
3691 }
3692
3693 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3694 where
3695 E: serde::de::Error,
3696 {
3697 i32::try_from(v)
3698 .ok()
3699 .and_then(|x| x.try_into().ok())
3700 .ok_or_else(|| {
3701 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3702 })
3703 }
3704
3705 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3706 where
3707 E: serde::de::Error,
3708 {
3709 match value {
3710 "ICEBERG_SCAN_TYPE_UNSPECIFIED" => Ok(iceberg_scan_node::IcebergScanType::Unspecified),
3711 "ICEBERG_SCAN_TYPE_DATA_SCAN" => Ok(iceberg_scan_node::IcebergScanType::DataScan),
3712 "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::EqualityDeleteScan),
3713 "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::PositionDeleteScan),
3714 "ICEBERG_SCAN_TYPE_COUNT_STAR" => Ok(iceberg_scan_node::IcebergScanType::CountStar),
3715 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3716 }
3717 }
3718 }
3719 deserializer.deserialize_any(GeneratedVisitor)
3720 }
3721}
3722impl serde::Serialize for InsertNode {
3723 #[allow(deprecated)]
3724 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3725 where
3726 S: serde::Serializer,
3727 {
3728 use serde::ser::SerializeStruct;
3729 let mut len = 0;
3730 if self.table_id != 0 {
3731 len += 1;
3732 }
3733 if self.table_version_id != 0 {
3734 len += 1;
3735 }
3736 if !self.column_indices.is_empty() {
3737 len += 1;
3738 }
3739 if self.default_columns.is_some() {
3740 len += 1;
3741 }
3742 if self.row_id_index.is_some() {
3743 len += 1;
3744 }
3745 if self.returning {
3746 len += 1;
3747 }
3748 if self.session_id != 0 {
3749 len += 1;
3750 }
3751 if self.wait_for_persistence {
3752 len += 1;
3753 }
3754 let mut struct_ser = serializer.serialize_struct("batch_plan.InsertNode", len)?;
3755 if self.table_id != 0 {
3756 struct_ser.serialize_field("tableId", &self.table_id)?;
3757 }
3758 if self.table_version_id != 0 {
3759 #[allow(clippy::needless_borrow)]
3760 #[allow(clippy::needless_borrows_for_generic_args)]
3761 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3762 }
3763 if !self.column_indices.is_empty() {
3764 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
3765 }
3766 if let Some(v) = self.default_columns.as_ref() {
3767 struct_ser.serialize_field("defaultColumns", v)?;
3768 }
3769 if let Some(v) = self.row_id_index.as_ref() {
3770 struct_ser.serialize_field("rowIdIndex", v)?;
3771 }
3772 if self.returning {
3773 struct_ser.serialize_field("returning", &self.returning)?;
3774 }
3775 if self.session_id != 0 {
3776 struct_ser.serialize_field("sessionId", &self.session_id)?;
3777 }
3778 if self.wait_for_persistence {
3779 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
3780 }
3781 struct_ser.end()
3782 }
3783}
3784impl<'de> serde::Deserialize<'de> for InsertNode {
3785 #[allow(deprecated)]
3786 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3787 where
3788 D: serde::Deserializer<'de>,
3789 {
3790 const FIELDS: &[&str] = &[
3791 "table_id",
3792 "tableId",
3793 "table_version_id",
3794 "tableVersionId",
3795 "column_indices",
3796 "columnIndices",
3797 "default_columns",
3798 "defaultColumns",
3799 "row_id_index",
3800 "rowIdIndex",
3801 "returning",
3802 "session_id",
3803 "sessionId",
3804 "wait_for_persistence",
3805 "waitForPersistence",
3806 ];
3807
3808 #[allow(clippy::enum_variant_names)]
3809 enum GeneratedField {
3810 TableId,
3811 TableVersionId,
3812 ColumnIndices,
3813 DefaultColumns,
3814 RowIdIndex,
3815 Returning,
3816 SessionId,
3817 WaitForPersistence,
3818 }
3819 impl<'de> serde::Deserialize<'de> for GeneratedField {
3820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3821 where
3822 D: serde::Deserializer<'de>,
3823 {
3824 struct GeneratedVisitor;
3825
3826 impl serde::de::Visitor<'_> for GeneratedVisitor {
3827 type Value = GeneratedField;
3828
3829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3830 write!(formatter, "expected one of: {:?}", &FIELDS)
3831 }
3832
3833 #[allow(unused_variables)]
3834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3835 where
3836 E: serde::de::Error,
3837 {
3838 match value {
3839 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3840 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3841 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
3842 "defaultColumns" | "default_columns" => Ok(GeneratedField::DefaultColumns),
3843 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
3844 "returning" => Ok(GeneratedField::Returning),
3845 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
3846 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
3847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3848 }
3849 }
3850 }
3851 deserializer.deserialize_identifier(GeneratedVisitor)
3852 }
3853 }
3854 struct GeneratedVisitor;
3855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3856 type Value = InsertNode;
3857
3858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3859 formatter.write_str("struct batch_plan.InsertNode")
3860 }
3861
3862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InsertNode, V::Error>
3863 where
3864 V: serde::de::MapAccess<'de>,
3865 {
3866 let mut table_id__ = None;
3867 let mut table_version_id__ = None;
3868 let mut column_indices__ = None;
3869 let mut default_columns__ = None;
3870 let mut row_id_index__ = None;
3871 let mut returning__ = None;
3872 let mut session_id__ = None;
3873 let mut wait_for_persistence__ = None;
3874 while let Some(k) = map_.next_key()? {
3875 match k {
3876 GeneratedField::TableId => {
3877 if table_id__.is_some() {
3878 return Err(serde::de::Error::duplicate_field("tableId"));
3879 }
3880 table_id__ =
3881 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3882 ;
3883 }
3884 GeneratedField::TableVersionId => {
3885 if table_version_id__.is_some() {
3886 return Err(serde::de::Error::duplicate_field("tableVersionId"));
3887 }
3888 table_version_id__ =
3889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3890 ;
3891 }
3892 GeneratedField::ColumnIndices => {
3893 if column_indices__.is_some() {
3894 return Err(serde::de::Error::duplicate_field("columnIndices"));
3895 }
3896 column_indices__ =
3897 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3898 .into_iter().map(|x| x.0).collect())
3899 ;
3900 }
3901 GeneratedField::DefaultColumns => {
3902 if default_columns__.is_some() {
3903 return Err(serde::de::Error::duplicate_field("defaultColumns"));
3904 }
3905 default_columns__ = map_.next_value()?;
3906 }
3907 GeneratedField::RowIdIndex => {
3908 if row_id_index__.is_some() {
3909 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
3910 }
3911 row_id_index__ =
3912 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3913 ;
3914 }
3915 GeneratedField::Returning => {
3916 if returning__.is_some() {
3917 return Err(serde::de::Error::duplicate_field("returning"));
3918 }
3919 returning__ = Some(map_.next_value()?);
3920 }
3921 GeneratedField::SessionId => {
3922 if session_id__.is_some() {
3923 return Err(serde::de::Error::duplicate_field("sessionId"));
3924 }
3925 session_id__ =
3926 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3927 ;
3928 }
3929 GeneratedField::WaitForPersistence => {
3930 if wait_for_persistence__.is_some() {
3931 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
3932 }
3933 wait_for_persistence__ = Some(map_.next_value()?);
3934 }
3935 }
3936 }
3937 Ok(InsertNode {
3938 table_id: table_id__.unwrap_or_default(),
3939 table_version_id: table_version_id__.unwrap_or_default(),
3940 column_indices: column_indices__.unwrap_or_default(),
3941 default_columns: default_columns__,
3942 row_id_index: row_id_index__,
3943 returning: returning__.unwrap_or_default(),
3944 session_id: session_id__.unwrap_or_default(),
3945 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
3946 })
3947 }
3948 }
3949 deserializer.deserialize_struct("batch_plan.InsertNode", FIELDS, GeneratedVisitor)
3950 }
3951}
3952impl serde::Serialize for LimitNode {
3953 #[allow(deprecated)]
3954 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3955 where
3956 S: serde::Serializer,
3957 {
3958 use serde::ser::SerializeStruct;
3959 let mut len = 0;
3960 if self.limit != 0 {
3961 len += 1;
3962 }
3963 if self.offset != 0 {
3964 len += 1;
3965 }
3966 let mut struct_ser = serializer.serialize_struct("batch_plan.LimitNode", len)?;
3967 if self.limit != 0 {
3968 #[allow(clippy::needless_borrow)]
3969 #[allow(clippy::needless_borrows_for_generic_args)]
3970 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
3971 }
3972 if self.offset != 0 {
3973 #[allow(clippy::needless_borrow)]
3974 #[allow(clippy::needless_borrows_for_generic_args)]
3975 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
3976 }
3977 struct_ser.end()
3978 }
3979}
3980impl<'de> serde::Deserialize<'de> for LimitNode {
3981 #[allow(deprecated)]
3982 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3983 where
3984 D: serde::Deserializer<'de>,
3985 {
3986 const FIELDS: &[&str] = &[
3987 "limit",
3988 "offset",
3989 ];
3990
3991 #[allow(clippy::enum_variant_names)]
3992 enum GeneratedField {
3993 Limit,
3994 Offset,
3995 }
3996 impl<'de> serde::Deserialize<'de> for GeneratedField {
3997 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3998 where
3999 D: serde::Deserializer<'de>,
4000 {
4001 struct GeneratedVisitor;
4002
4003 impl serde::de::Visitor<'_> for GeneratedVisitor {
4004 type Value = GeneratedField;
4005
4006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4007 write!(formatter, "expected one of: {:?}", &FIELDS)
4008 }
4009
4010 #[allow(unused_variables)]
4011 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4012 where
4013 E: serde::de::Error,
4014 {
4015 match value {
4016 "limit" => Ok(GeneratedField::Limit),
4017 "offset" => Ok(GeneratedField::Offset),
4018 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4019 }
4020 }
4021 }
4022 deserializer.deserialize_identifier(GeneratedVisitor)
4023 }
4024 }
4025 struct GeneratedVisitor;
4026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4027 type Value = LimitNode;
4028
4029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4030 formatter.write_str("struct batch_plan.LimitNode")
4031 }
4032
4033 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LimitNode, V::Error>
4034 where
4035 V: serde::de::MapAccess<'de>,
4036 {
4037 let mut limit__ = None;
4038 let mut offset__ = None;
4039 while let Some(k) = map_.next_key()? {
4040 match k {
4041 GeneratedField::Limit => {
4042 if limit__.is_some() {
4043 return Err(serde::de::Error::duplicate_field("limit"));
4044 }
4045 limit__ =
4046 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4047 ;
4048 }
4049 GeneratedField::Offset => {
4050 if offset__.is_some() {
4051 return Err(serde::de::Error::duplicate_field("offset"));
4052 }
4053 offset__ =
4054 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4055 ;
4056 }
4057 }
4058 }
4059 Ok(LimitNode {
4060 limit: limit__.unwrap_or_default(),
4061 offset: offset__.unwrap_or_default(),
4062 })
4063 }
4064 }
4065 deserializer.deserialize_struct("batch_plan.LimitNode", FIELDS, GeneratedVisitor)
4066 }
4067}
4068impl serde::Serialize for LocalExecutePlan {
4069 #[allow(deprecated)]
4070 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4071 where
4072 S: serde::Serializer,
4073 {
4074 use serde::ser::SerializeStruct;
4075 let mut len = 0;
4076 if self.plan.is_some() {
4077 len += 1;
4078 }
4079 if !self.tracing_context.is_empty() {
4080 len += 1;
4081 }
4082 let mut struct_ser = serializer.serialize_struct("batch_plan.LocalExecutePlan", len)?;
4083 if let Some(v) = self.plan.as_ref() {
4084 struct_ser.serialize_field("plan", v)?;
4085 }
4086 if !self.tracing_context.is_empty() {
4087 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
4088 }
4089 struct_ser.end()
4090 }
4091}
4092impl<'de> serde::Deserialize<'de> for LocalExecutePlan {
4093 #[allow(deprecated)]
4094 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4095 where
4096 D: serde::Deserializer<'de>,
4097 {
4098 const FIELDS: &[&str] = &[
4099 "plan",
4100 "tracing_context",
4101 "tracingContext",
4102 ];
4103
4104 #[allow(clippy::enum_variant_names)]
4105 enum GeneratedField {
4106 Plan,
4107 TracingContext,
4108 }
4109 impl<'de> serde::Deserialize<'de> for GeneratedField {
4110 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4111 where
4112 D: serde::Deserializer<'de>,
4113 {
4114 struct GeneratedVisitor;
4115
4116 impl serde::de::Visitor<'_> for GeneratedVisitor {
4117 type Value = GeneratedField;
4118
4119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4120 write!(formatter, "expected one of: {:?}", &FIELDS)
4121 }
4122
4123 #[allow(unused_variables)]
4124 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4125 where
4126 E: serde::de::Error,
4127 {
4128 match value {
4129 "plan" => Ok(GeneratedField::Plan),
4130 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
4131 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4132 }
4133 }
4134 }
4135 deserializer.deserialize_identifier(GeneratedVisitor)
4136 }
4137 }
4138 struct GeneratedVisitor;
4139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4140 type Value = LocalExecutePlan;
4141
4142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4143 formatter.write_str("struct batch_plan.LocalExecutePlan")
4144 }
4145
4146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalExecutePlan, V::Error>
4147 where
4148 V: serde::de::MapAccess<'de>,
4149 {
4150 let mut plan__ = None;
4151 let mut tracing_context__ = None;
4152 while let Some(k) = map_.next_key()? {
4153 match k {
4154 GeneratedField::Plan => {
4155 if plan__.is_some() {
4156 return Err(serde::de::Error::duplicate_field("plan"));
4157 }
4158 plan__ = map_.next_value()?;
4159 }
4160 GeneratedField::TracingContext => {
4161 if tracing_context__.is_some() {
4162 return Err(serde::de::Error::duplicate_field("tracingContext"));
4163 }
4164 tracing_context__ = Some(
4165 map_.next_value::<std::collections::HashMap<_, _>>()?
4166 );
4167 }
4168 }
4169 }
4170 Ok(LocalExecutePlan {
4171 plan: plan__,
4172 tracing_context: tracing_context__.unwrap_or_default(),
4173 })
4174 }
4175 }
4176 deserializer.deserialize_struct("batch_plan.LocalExecutePlan", FIELDS, GeneratedVisitor)
4177 }
4178}
4179impl serde::Serialize for LocalLookupJoinNode {
4180 #[allow(deprecated)]
4181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4182 where
4183 S: serde::Serializer,
4184 {
4185 use serde::ser::SerializeStruct;
4186 let mut len = 0;
4187 if self.join_type != 0 {
4188 len += 1;
4189 }
4190 if self.condition.is_some() {
4191 len += 1;
4192 }
4193 if !self.outer_side_key.is_empty() {
4194 len += 1;
4195 }
4196 if !self.inner_side_key.is_empty() {
4197 len += 1;
4198 }
4199 if self.lookup_prefix_len != 0 {
4200 len += 1;
4201 }
4202 if self.inner_side_table_desc.is_some() {
4203 len += 1;
4204 }
4205 if !self.inner_side_vnode_mapping.is_empty() {
4206 len += 1;
4207 }
4208 if !self.inner_side_column_ids.is_empty() {
4209 len += 1;
4210 }
4211 if !self.output_indices.is_empty() {
4212 len += 1;
4213 }
4214 if !self.worker_nodes.is_empty() {
4215 len += 1;
4216 }
4217 if !self.null_safe.is_empty() {
4218 len += 1;
4219 }
4220 if self.query_epoch.is_some() {
4221 len += 1;
4222 }
4223 if self.asof_desc.is_some() {
4224 len += 1;
4225 }
4226 let mut struct_ser = serializer.serialize_struct("batch_plan.LocalLookupJoinNode", len)?;
4227 if self.join_type != 0 {
4228 let v = super::plan_common::JoinType::try_from(self.join_type)
4229 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
4230 struct_ser.serialize_field("joinType", &v)?;
4231 }
4232 if let Some(v) = self.condition.as_ref() {
4233 struct_ser.serialize_field("condition", v)?;
4234 }
4235 if !self.outer_side_key.is_empty() {
4236 struct_ser.serialize_field("outerSideKey", &self.outer_side_key)?;
4237 }
4238 if !self.inner_side_key.is_empty() {
4239 struct_ser.serialize_field("innerSideKey", &self.inner_side_key)?;
4240 }
4241 if self.lookup_prefix_len != 0 {
4242 struct_ser.serialize_field("lookupPrefixLen", &self.lookup_prefix_len)?;
4243 }
4244 if let Some(v) = self.inner_side_table_desc.as_ref() {
4245 struct_ser.serialize_field("innerSideTableDesc", v)?;
4246 }
4247 if !self.inner_side_vnode_mapping.is_empty() {
4248 struct_ser.serialize_field("innerSideVnodeMapping", &self.inner_side_vnode_mapping.iter().map(ToString::to_string).collect::<Vec<_>>())?;
4249 }
4250 if !self.inner_side_column_ids.is_empty() {
4251 struct_ser.serialize_field("innerSideColumnIds", &self.inner_side_column_ids)?;
4252 }
4253 if !self.output_indices.is_empty() {
4254 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
4255 }
4256 if !self.worker_nodes.is_empty() {
4257 struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
4258 }
4259 if !self.null_safe.is_empty() {
4260 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
4261 }
4262 if let Some(v) = self.query_epoch.as_ref() {
4263 struct_ser.serialize_field("queryEpoch", v)?;
4264 }
4265 if let Some(v) = self.asof_desc.as_ref() {
4266 struct_ser.serialize_field("asofDesc", v)?;
4267 }
4268 struct_ser.end()
4269 }
4270}
4271impl<'de> serde::Deserialize<'de> for LocalLookupJoinNode {
4272 #[allow(deprecated)]
4273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4274 where
4275 D: serde::Deserializer<'de>,
4276 {
4277 const FIELDS: &[&str] = &[
4278 "join_type",
4279 "joinType",
4280 "condition",
4281 "outer_side_key",
4282 "outerSideKey",
4283 "inner_side_key",
4284 "innerSideKey",
4285 "lookup_prefix_len",
4286 "lookupPrefixLen",
4287 "inner_side_table_desc",
4288 "innerSideTableDesc",
4289 "inner_side_vnode_mapping",
4290 "innerSideVnodeMapping",
4291 "inner_side_column_ids",
4292 "innerSideColumnIds",
4293 "output_indices",
4294 "outputIndices",
4295 "worker_nodes",
4296 "workerNodes",
4297 "null_safe",
4298 "nullSafe",
4299 "query_epoch",
4300 "queryEpoch",
4301 "asof_desc",
4302 "asofDesc",
4303 ];
4304
4305 #[allow(clippy::enum_variant_names)]
4306 enum GeneratedField {
4307 JoinType,
4308 Condition,
4309 OuterSideKey,
4310 InnerSideKey,
4311 LookupPrefixLen,
4312 InnerSideTableDesc,
4313 InnerSideVnodeMapping,
4314 InnerSideColumnIds,
4315 OutputIndices,
4316 WorkerNodes,
4317 NullSafe,
4318 QueryEpoch,
4319 AsofDesc,
4320 }
4321 impl<'de> serde::Deserialize<'de> for GeneratedField {
4322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4323 where
4324 D: serde::Deserializer<'de>,
4325 {
4326 struct GeneratedVisitor;
4327
4328 impl serde::de::Visitor<'_> for GeneratedVisitor {
4329 type Value = GeneratedField;
4330
4331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4332 write!(formatter, "expected one of: {:?}", &FIELDS)
4333 }
4334
4335 #[allow(unused_variables)]
4336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4337 where
4338 E: serde::de::Error,
4339 {
4340 match value {
4341 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
4342 "condition" => Ok(GeneratedField::Condition),
4343 "outerSideKey" | "outer_side_key" => Ok(GeneratedField::OuterSideKey),
4344 "innerSideKey" | "inner_side_key" => Ok(GeneratedField::InnerSideKey),
4345 "lookupPrefixLen" | "lookup_prefix_len" => Ok(GeneratedField::LookupPrefixLen),
4346 "innerSideTableDesc" | "inner_side_table_desc" => Ok(GeneratedField::InnerSideTableDesc),
4347 "innerSideVnodeMapping" | "inner_side_vnode_mapping" => Ok(GeneratedField::InnerSideVnodeMapping),
4348 "innerSideColumnIds" | "inner_side_column_ids" => Ok(GeneratedField::InnerSideColumnIds),
4349 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
4350 "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
4351 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
4352 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
4353 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
4354 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4355 }
4356 }
4357 }
4358 deserializer.deserialize_identifier(GeneratedVisitor)
4359 }
4360 }
4361 struct GeneratedVisitor;
4362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4363 type Value = LocalLookupJoinNode;
4364
4365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4366 formatter.write_str("struct batch_plan.LocalLookupJoinNode")
4367 }
4368
4369 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalLookupJoinNode, V::Error>
4370 where
4371 V: serde::de::MapAccess<'de>,
4372 {
4373 let mut join_type__ = None;
4374 let mut condition__ = None;
4375 let mut outer_side_key__ = None;
4376 let mut inner_side_key__ = None;
4377 let mut lookup_prefix_len__ = None;
4378 let mut inner_side_table_desc__ = None;
4379 let mut inner_side_vnode_mapping__ = None;
4380 let mut inner_side_column_ids__ = None;
4381 let mut output_indices__ = None;
4382 let mut worker_nodes__ = None;
4383 let mut null_safe__ = None;
4384 let mut query_epoch__ = None;
4385 let mut asof_desc__ = None;
4386 while let Some(k) = map_.next_key()? {
4387 match k {
4388 GeneratedField::JoinType => {
4389 if join_type__.is_some() {
4390 return Err(serde::de::Error::duplicate_field("joinType"));
4391 }
4392 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
4393 }
4394 GeneratedField::Condition => {
4395 if condition__.is_some() {
4396 return Err(serde::de::Error::duplicate_field("condition"));
4397 }
4398 condition__ = map_.next_value()?;
4399 }
4400 GeneratedField::OuterSideKey => {
4401 if outer_side_key__.is_some() {
4402 return Err(serde::de::Error::duplicate_field("outerSideKey"));
4403 }
4404 outer_side_key__ =
4405 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4406 .into_iter().map(|x| x.0).collect())
4407 ;
4408 }
4409 GeneratedField::InnerSideKey => {
4410 if inner_side_key__.is_some() {
4411 return Err(serde::de::Error::duplicate_field("innerSideKey"));
4412 }
4413 inner_side_key__ =
4414 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4415 .into_iter().map(|x| x.0).collect())
4416 ;
4417 }
4418 GeneratedField::LookupPrefixLen => {
4419 if lookup_prefix_len__.is_some() {
4420 return Err(serde::de::Error::duplicate_field("lookupPrefixLen"));
4421 }
4422 lookup_prefix_len__ =
4423 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4424 ;
4425 }
4426 GeneratedField::InnerSideTableDesc => {
4427 if inner_side_table_desc__.is_some() {
4428 return Err(serde::de::Error::duplicate_field("innerSideTableDesc"));
4429 }
4430 inner_side_table_desc__ = map_.next_value()?;
4431 }
4432 GeneratedField::InnerSideVnodeMapping => {
4433 if inner_side_vnode_mapping__.is_some() {
4434 return Err(serde::de::Error::duplicate_field("innerSideVnodeMapping"));
4435 }
4436 inner_side_vnode_mapping__ =
4437 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4438 .into_iter().map(|x| x.0).collect())
4439 ;
4440 }
4441 GeneratedField::InnerSideColumnIds => {
4442 if inner_side_column_ids__.is_some() {
4443 return Err(serde::de::Error::duplicate_field("innerSideColumnIds"));
4444 }
4445 inner_side_column_ids__ =
4446 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4447 .into_iter().map(|x| x.0).collect())
4448 ;
4449 }
4450 GeneratedField::OutputIndices => {
4451 if output_indices__.is_some() {
4452 return Err(serde::de::Error::duplicate_field("outputIndices"));
4453 }
4454 output_indices__ =
4455 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4456 .into_iter().map(|x| x.0).collect())
4457 ;
4458 }
4459 GeneratedField::WorkerNodes => {
4460 if worker_nodes__.is_some() {
4461 return Err(serde::de::Error::duplicate_field("workerNodes"));
4462 }
4463 worker_nodes__ = Some(map_.next_value()?);
4464 }
4465 GeneratedField::NullSafe => {
4466 if null_safe__.is_some() {
4467 return Err(serde::de::Error::duplicate_field("nullSafe"));
4468 }
4469 null_safe__ = Some(map_.next_value()?);
4470 }
4471 GeneratedField::QueryEpoch => {
4472 if query_epoch__.is_some() {
4473 return Err(serde::de::Error::duplicate_field("queryEpoch"));
4474 }
4475 query_epoch__ = map_.next_value()?;
4476 }
4477 GeneratedField::AsofDesc => {
4478 if asof_desc__.is_some() {
4479 return Err(serde::de::Error::duplicate_field("asofDesc"));
4480 }
4481 asof_desc__ = map_.next_value()?;
4482 }
4483 }
4484 }
4485 Ok(LocalLookupJoinNode {
4486 join_type: join_type__.unwrap_or_default(),
4487 condition: condition__,
4488 outer_side_key: outer_side_key__.unwrap_or_default(),
4489 inner_side_key: inner_side_key__.unwrap_or_default(),
4490 lookup_prefix_len: lookup_prefix_len__.unwrap_or_default(),
4491 inner_side_table_desc: inner_side_table_desc__,
4492 inner_side_vnode_mapping: inner_side_vnode_mapping__.unwrap_or_default(),
4493 inner_side_column_ids: inner_side_column_ids__.unwrap_or_default(),
4494 output_indices: output_indices__.unwrap_or_default(),
4495 worker_nodes: worker_nodes__.unwrap_or_default(),
4496 null_safe: null_safe__.unwrap_or_default(),
4497 query_epoch: query_epoch__,
4498 asof_desc: asof_desc__,
4499 })
4500 }
4501 }
4502 deserializer.deserialize_struct("batch_plan.LocalLookupJoinNode", FIELDS, GeneratedVisitor)
4503 }
4504}
4505impl serde::Serialize for LogRowSeqScanNode {
4506 #[allow(deprecated)]
4507 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4508 where
4509 S: serde::Serializer,
4510 {
4511 use serde::ser::SerializeStruct;
4512 let mut len = 0;
4513 if self.table_desc.is_some() {
4514 len += 1;
4515 }
4516 if !self.column_ids.is_empty() {
4517 len += 1;
4518 }
4519 if self.vnode_bitmap.is_some() {
4520 len += 1;
4521 }
4522 if self.old_epoch.is_some() {
4523 len += 1;
4524 }
4525 if self.new_epoch.is_some() {
4526 len += 1;
4527 }
4528 if self.ordered {
4529 len += 1;
4530 }
4531 if self.scan_range.is_some() {
4532 len += 1;
4533 }
4534 let mut struct_ser = serializer.serialize_struct("batch_plan.LogRowSeqScanNode", len)?;
4535 if let Some(v) = self.table_desc.as_ref() {
4536 struct_ser.serialize_field("tableDesc", v)?;
4537 }
4538 if !self.column_ids.is_empty() {
4539 struct_ser.serialize_field("columnIds", &self.column_ids)?;
4540 }
4541 if let Some(v) = self.vnode_bitmap.as_ref() {
4542 struct_ser.serialize_field("vnodeBitmap", v)?;
4543 }
4544 if let Some(v) = self.old_epoch.as_ref() {
4545 struct_ser.serialize_field("oldEpoch", v)?;
4546 }
4547 if let Some(v) = self.new_epoch.as_ref() {
4548 struct_ser.serialize_field("newEpoch", v)?;
4549 }
4550 if self.ordered {
4551 struct_ser.serialize_field("ordered", &self.ordered)?;
4552 }
4553 if let Some(v) = self.scan_range.as_ref() {
4554 struct_ser.serialize_field("scanRange", v)?;
4555 }
4556 struct_ser.end()
4557 }
4558}
4559impl<'de> serde::Deserialize<'de> for LogRowSeqScanNode {
4560 #[allow(deprecated)]
4561 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4562 where
4563 D: serde::Deserializer<'de>,
4564 {
4565 const FIELDS: &[&str] = &[
4566 "table_desc",
4567 "tableDesc",
4568 "column_ids",
4569 "columnIds",
4570 "vnode_bitmap",
4571 "vnodeBitmap",
4572 "old_epoch",
4573 "oldEpoch",
4574 "new_epoch",
4575 "newEpoch",
4576 "ordered",
4577 "scan_range",
4578 "scanRange",
4579 ];
4580
4581 #[allow(clippy::enum_variant_names)]
4582 enum GeneratedField {
4583 TableDesc,
4584 ColumnIds,
4585 VnodeBitmap,
4586 OldEpoch,
4587 NewEpoch,
4588 Ordered,
4589 ScanRange,
4590 }
4591 impl<'de> serde::Deserialize<'de> for GeneratedField {
4592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4593 where
4594 D: serde::Deserializer<'de>,
4595 {
4596 struct GeneratedVisitor;
4597
4598 impl serde::de::Visitor<'_> for GeneratedVisitor {
4599 type Value = GeneratedField;
4600
4601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4602 write!(formatter, "expected one of: {:?}", &FIELDS)
4603 }
4604
4605 #[allow(unused_variables)]
4606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4607 where
4608 E: serde::de::Error,
4609 {
4610 match value {
4611 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
4612 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
4613 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
4614 "oldEpoch" | "old_epoch" => Ok(GeneratedField::OldEpoch),
4615 "newEpoch" | "new_epoch" => Ok(GeneratedField::NewEpoch),
4616 "ordered" => Ok(GeneratedField::Ordered),
4617 "scanRange" | "scan_range" => Ok(GeneratedField::ScanRange),
4618 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4619 }
4620 }
4621 }
4622 deserializer.deserialize_identifier(GeneratedVisitor)
4623 }
4624 }
4625 struct GeneratedVisitor;
4626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4627 type Value = LogRowSeqScanNode;
4628
4629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4630 formatter.write_str("struct batch_plan.LogRowSeqScanNode")
4631 }
4632
4633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LogRowSeqScanNode, V::Error>
4634 where
4635 V: serde::de::MapAccess<'de>,
4636 {
4637 let mut table_desc__ = None;
4638 let mut column_ids__ = None;
4639 let mut vnode_bitmap__ = None;
4640 let mut old_epoch__ = None;
4641 let mut new_epoch__ = None;
4642 let mut ordered__ = None;
4643 let mut scan_range__ = None;
4644 while let Some(k) = map_.next_key()? {
4645 match k {
4646 GeneratedField::TableDesc => {
4647 if table_desc__.is_some() {
4648 return Err(serde::de::Error::duplicate_field("tableDesc"));
4649 }
4650 table_desc__ = map_.next_value()?;
4651 }
4652 GeneratedField::ColumnIds => {
4653 if column_ids__.is_some() {
4654 return Err(serde::de::Error::duplicate_field("columnIds"));
4655 }
4656 column_ids__ =
4657 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4658 .into_iter().map(|x| x.0).collect())
4659 ;
4660 }
4661 GeneratedField::VnodeBitmap => {
4662 if vnode_bitmap__.is_some() {
4663 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
4664 }
4665 vnode_bitmap__ = map_.next_value()?;
4666 }
4667 GeneratedField::OldEpoch => {
4668 if old_epoch__.is_some() {
4669 return Err(serde::de::Error::duplicate_field("oldEpoch"));
4670 }
4671 old_epoch__ = map_.next_value()?;
4672 }
4673 GeneratedField::NewEpoch => {
4674 if new_epoch__.is_some() {
4675 return Err(serde::de::Error::duplicate_field("newEpoch"));
4676 }
4677 new_epoch__ = map_.next_value()?;
4678 }
4679 GeneratedField::Ordered => {
4680 if ordered__.is_some() {
4681 return Err(serde::de::Error::duplicate_field("ordered"));
4682 }
4683 ordered__ = Some(map_.next_value()?);
4684 }
4685 GeneratedField::ScanRange => {
4686 if scan_range__.is_some() {
4687 return Err(serde::de::Error::duplicate_field("scanRange"));
4688 }
4689 scan_range__ = map_.next_value()?;
4690 }
4691 }
4692 }
4693 Ok(LogRowSeqScanNode {
4694 table_desc: table_desc__,
4695 column_ids: column_ids__.unwrap_or_default(),
4696 vnode_bitmap: vnode_bitmap__,
4697 old_epoch: old_epoch__,
4698 new_epoch: new_epoch__,
4699 ordered: ordered__.unwrap_or_default(),
4700 scan_range: scan_range__,
4701 })
4702 }
4703 }
4704 deserializer.deserialize_struct("batch_plan.LogRowSeqScanNode", FIELDS, GeneratedVisitor)
4705 }
4706}
4707impl serde::Serialize for MaxOneRowNode {
4708 #[allow(deprecated)]
4709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4710 where
4711 S: serde::Serializer,
4712 {
4713 use serde::ser::SerializeStruct;
4714 let len = 0;
4715 let struct_ser = serializer.serialize_struct("batch_plan.MaxOneRowNode", len)?;
4716 struct_ser.end()
4717 }
4718}
4719impl<'de> serde::Deserialize<'de> for MaxOneRowNode {
4720 #[allow(deprecated)]
4721 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4722 where
4723 D: serde::Deserializer<'de>,
4724 {
4725 const FIELDS: &[&str] = &[
4726 ];
4727
4728 #[allow(clippy::enum_variant_names)]
4729 enum GeneratedField {
4730 }
4731 impl<'de> serde::Deserialize<'de> for GeneratedField {
4732 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4733 where
4734 D: serde::Deserializer<'de>,
4735 {
4736 struct GeneratedVisitor;
4737
4738 impl serde::de::Visitor<'_> for GeneratedVisitor {
4739 type Value = GeneratedField;
4740
4741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4742 write!(formatter, "expected one of: {:?}", &FIELDS)
4743 }
4744
4745 #[allow(unused_variables)]
4746 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4747 where
4748 E: serde::de::Error,
4749 {
4750 Err(serde::de::Error::unknown_field(value, FIELDS))
4751 }
4752 }
4753 deserializer.deserialize_identifier(GeneratedVisitor)
4754 }
4755 }
4756 struct GeneratedVisitor;
4757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4758 type Value = MaxOneRowNode;
4759
4760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4761 formatter.write_str("struct batch_plan.MaxOneRowNode")
4762 }
4763
4764 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaxOneRowNode, V::Error>
4765 where
4766 V: serde::de::MapAccess<'de>,
4767 {
4768 while map_.next_key::<GeneratedField>()?.is_some() {
4769 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4770 }
4771 Ok(MaxOneRowNode {
4772 })
4773 }
4774 }
4775 deserializer.deserialize_struct("batch_plan.MaxOneRowNode", FIELDS, GeneratedVisitor)
4776 }
4777}
4778impl serde::Serialize for MergeSortExchangeNode {
4779 #[allow(deprecated)]
4780 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4781 where
4782 S: serde::Serializer,
4783 {
4784 use serde::ser::SerializeStruct;
4785 let mut len = 0;
4786 if self.exchange.is_some() {
4787 len += 1;
4788 }
4789 if !self.column_orders.is_empty() {
4790 len += 1;
4791 }
4792 let mut struct_ser = serializer.serialize_struct("batch_plan.MergeSortExchangeNode", len)?;
4793 if let Some(v) = self.exchange.as_ref() {
4794 struct_ser.serialize_field("exchange", v)?;
4795 }
4796 if !self.column_orders.is_empty() {
4797 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
4798 }
4799 struct_ser.end()
4800 }
4801}
4802impl<'de> serde::Deserialize<'de> for MergeSortExchangeNode {
4803 #[allow(deprecated)]
4804 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4805 where
4806 D: serde::Deserializer<'de>,
4807 {
4808 const FIELDS: &[&str] = &[
4809 "exchange",
4810 "column_orders",
4811 "columnOrders",
4812 ];
4813
4814 #[allow(clippy::enum_variant_names)]
4815 enum GeneratedField {
4816 Exchange,
4817 ColumnOrders,
4818 }
4819 impl<'de> serde::Deserialize<'de> for GeneratedField {
4820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4821 where
4822 D: serde::Deserializer<'de>,
4823 {
4824 struct GeneratedVisitor;
4825
4826 impl serde::de::Visitor<'_> for GeneratedVisitor {
4827 type Value = GeneratedField;
4828
4829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4830 write!(formatter, "expected one of: {:?}", &FIELDS)
4831 }
4832
4833 #[allow(unused_variables)]
4834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4835 where
4836 E: serde::de::Error,
4837 {
4838 match value {
4839 "exchange" => Ok(GeneratedField::Exchange),
4840 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
4841 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4842 }
4843 }
4844 }
4845 deserializer.deserialize_identifier(GeneratedVisitor)
4846 }
4847 }
4848 struct GeneratedVisitor;
4849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4850 type Value = MergeSortExchangeNode;
4851
4852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4853 formatter.write_str("struct batch_plan.MergeSortExchangeNode")
4854 }
4855
4856 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeSortExchangeNode, V::Error>
4857 where
4858 V: serde::de::MapAccess<'de>,
4859 {
4860 let mut exchange__ = None;
4861 let mut column_orders__ = None;
4862 while let Some(k) = map_.next_key()? {
4863 match k {
4864 GeneratedField::Exchange => {
4865 if exchange__.is_some() {
4866 return Err(serde::de::Error::duplicate_field("exchange"));
4867 }
4868 exchange__ = map_.next_value()?;
4869 }
4870 GeneratedField::ColumnOrders => {
4871 if column_orders__.is_some() {
4872 return Err(serde::de::Error::duplicate_field("columnOrders"));
4873 }
4874 column_orders__ = Some(map_.next_value()?);
4875 }
4876 }
4877 }
4878 Ok(MergeSortExchangeNode {
4879 exchange: exchange__,
4880 column_orders: column_orders__.unwrap_or_default(),
4881 })
4882 }
4883 }
4884 deserializer.deserialize_struct("batch_plan.MergeSortExchangeNode", FIELDS, GeneratedVisitor)
4885 }
4886}
4887impl serde::Serialize for MySqlQueryNode {
4888 #[allow(deprecated)]
4889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4890 where
4891 S: serde::Serializer,
4892 {
4893 use serde::ser::SerializeStruct;
4894 let mut len = 0;
4895 if !self.columns.is_empty() {
4896 len += 1;
4897 }
4898 if !self.hostname.is_empty() {
4899 len += 1;
4900 }
4901 if !self.port.is_empty() {
4902 len += 1;
4903 }
4904 if !self.username.is_empty() {
4905 len += 1;
4906 }
4907 if !self.password.is_empty() {
4908 len += 1;
4909 }
4910 if !self.database.is_empty() {
4911 len += 1;
4912 }
4913 if !self.query.is_empty() {
4914 len += 1;
4915 }
4916 let mut struct_ser = serializer.serialize_struct("batch_plan.MySqlQueryNode", len)?;
4917 if !self.columns.is_empty() {
4918 struct_ser.serialize_field("columns", &self.columns)?;
4919 }
4920 if !self.hostname.is_empty() {
4921 struct_ser.serialize_field("hostname", &self.hostname)?;
4922 }
4923 if !self.port.is_empty() {
4924 struct_ser.serialize_field("port", &self.port)?;
4925 }
4926 if !self.username.is_empty() {
4927 struct_ser.serialize_field("username", &self.username)?;
4928 }
4929 if !self.password.is_empty() {
4930 struct_ser.serialize_field("password", &self.password)?;
4931 }
4932 if !self.database.is_empty() {
4933 struct_ser.serialize_field("database", &self.database)?;
4934 }
4935 if !self.query.is_empty() {
4936 struct_ser.serialize_field("query", &self.query)?;
4937 }
4938 struct_ser.end()
4939 }
4940}
4941impl<'de> serde::Deserialize<'de> for MySqlQueryNode {
4942 #[allow(deprecated)]
4943 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4944 where
4945 D: serde::Deserializer<'de>,
4946 {
4947 const FIELDS: &[&str] = &[
4948 "columns",
4949 "hostname",
4950 "port",
4951 "username",
4952 "password",
4953 "database",
4954 "query",
4955 ];
4956
4957 #[allow(clippy::enum_variant_names)]
4958 enum GeneratedField {
4959 Columns,
4960 Hostname,
4961 Port,
4962 Username,
4963 Password,
4964 Database,
4965 Query,
4966 }
4967 impl<'de> serde::Deserialize<'de> for GeneratedField {
4968 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4969 where
4970 D: serde::Deserializer<'de>,
4971 {
4972 struct GeneratedVisitor;
4973
4974 impl serde::de::Visitor<'_> for GeneratedVisitor {
4975 type Value = GeneratedField;
4976
4977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4978 write!(formatter, "expected one of: {:?}", &FIELDS)
4979 }
4980
4981 #[allow(unused_variables)]
4982 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4983 where
4984 E: serde::de::Error,
4985 {
4986 match value {
4987 "columns" => Ok(GeneratedField::Columns),
4988 "hostname" => Ok(GeneratedField::Hostname),
4989 "port" => Ok(GeneratedField::Port),
4990 "username" => Ok(GeneratedField::Username),
4991 "password" => Ok(GeneratedField::Password),
4992 "database" => Ok(GeneratedField::Database),
4993 "query" => Ok(GeneratedField::Query),
4994 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4995 }
4996 }
4997 }
4998 deserializer.deserialize_identifier(GeneratedVisitor)
4999 }
5000 }
5001 struct GeneratedVisitor;
5002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5003 type Value = MySqlQueryNode;
5004
5005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5006 formatter.write_str("struct batch_plan.MySqlQueryNode")
5007 }
5008
5009 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MySqlQueryNode, V::Error>
5010 where
5011 V: serde::de::MapAccess<'de>,
5012 {
5013 let mut columns__ = None;
5014 let mut hostname__ = None;
5015 let mut port__ = None;
5016 let mut username__ = None;
5017 let mut password__ = None;
5018 let mut database__ = None;
5019 let mut query__ = None;
5020 while let Some(k) = map_.next_key()? {
5021 match k {
5022 GeneratedField::Columns => {
5023 if columns__.is_some() {
5024 return Err(serde::de::Error::duplicate_field("columns"));
5025 }
5026 columns__ = Some(map_.next_value()?);
5027 }
5028 GeneratedField::Hostname => {
5029 if hostname__.is_some() {
5030 return Err(serde::de::Error::duplicate_field("hostname"));
5031 }
5032 hostname__ = Some(map_.next_value()?);
5033 }
5034 GeneratedField::Port => {
5035 if port__.is_some() {
5036 return Err(serde::de::Error::duplicate_field("port"));
5037 }
5038 port__ = Some(map_.next_value()?);
5039 }
5040 GeneratedField::Username => {
5041 if username__.is_some() {
5042 return Err(serde::de::Error::duplicate_field("username"));
5043 }
5044 username__ = Some(map_.next_value()?);
5045 }
5046 GeneratedField::Password => {
5047 if password__.is_some() {
5048 return Err(serde::de::Error::duplicate_field("password"));
5049 }
5050 password__ = Some(map_.next_value()?);
5051 }
5052 GeneratedField::Database => {
5053 if database__.is_some() {
5054 return Err(serde::de::Error::duplicate_field("database"));
5055 }
5056 database__ = Some(map_.next_value()?);
5057 }
5058 GeneratedField::Query => {
5059 if query__.is_some() {
5060 return Err(serde::de::Error::duplicate_field("query"));
5061 }
5062 query__ = Some(map_.next_value()?);
5063 }
5064 }
5065 }
5066 Ok(MySqlQueryNode {
5067 columns: columns__.unwrap_or_default(),
5068 hostname: hostname__.unwrap_or_default(),
5069 port: port__.unwrap_or_default(),
5070 username: username__.unwrap_or_default(),
5071 password: password__.unwrap_or_default(),
5072 database: database__.unwrap_or_default(),
5073 query: query__.unwrap_or_default(),
5074 })
5075 }
5076 }
5077 deserializer.deserialize_struct("batch_plan.MySqlQueryNode", FIELDS, GeneratedVisitor)
5078 }
5079}
5080impl serde::Serialize for NestedLoopJoinNode {
5081 #[allow(deprecated)]
5082 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5083 where
5084 S: serde::Serializer,
5085 {
5086 use serde::ser::SerializeStruct;
5087 let mut len = 0;
5088 if self.join_type != 0 {
5089 len += 1;
5090 }
5091 if self.join_cond.is_some() {
5092 len += 1;
5093 }
5094 if !self.output_indices.is_empty() {
5095 len += 1;
5096 }
5097 let mut struct_ser = serializer.serialize_struct("batch_plan.NestedLoopJoinNode", len)?;
5098 if self.join_type != 0 {
5099 let v = super::plan_common::JoinType::try_from(self.join_type)
5100 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5101 struct_ser.serialize_field("joinType", &v)?;
5102 }
5103 if let Some(v) = self.join_cond.as_ref() {
5104 struct_ser.serialize_field("joinCond", v)?;
5105 }
5106 if !self.output_indices.is_empty() {
5107 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5108 }
5109 struct_ser.end()
5110 }
5111}
5112impl<'de> serde::Deserialize<'de> for NestedLoopJoinNode {
5113 #[allow(deprecated)]
5114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5115 where
5116 D: serde::Deserializer<'de>,
5117 {
5118 const FIELDS: &[&str] = &[
5119 "join_type",
5120 "joinType",
5121 "join_cond",
5122 "joinCond",
5123 "output_indices",
5124 "outputIndices",
5125 ];
5126
5127 #[allow(clippy::enum_variant_names)]
5128 enum GeneratedField {
5129 JoinType,
5130 JoinCond,
5131 OutputIndices,
5132 }
5133 impl<'de> serde::Deserialize<'de> for GeneratedField {
5134 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5135 where
5136 D: serde::Deserializer<'de>,
5137 {
5138 struct GeneratedVisitor;
5139
5140 impl serde::de::Visitor<'_> for GeneratedVisitor {
5141 type Value = GeneratedField;
5142
5143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5144 write!(formatter, "expected one of: {:?}", &FIELDS)
5145 }
5146
5147 #[allow(unused_variables)]
5148 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5149 where
5150 E: serde::de::Error,
5151 {
5152 match value {
5153 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5154 "joinCond" | "join_cond" => Ok(GeneratedField::JoinCond),
5155 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5157 }
5158 }
5159 }
5160 deserializer.deserialize_identifier(GeneratedVisitor)
5161 }
5162 }
5163 struct GeneratedVisitor;
5164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5165 type Value = NestedLoopJoinNode;
5166
5167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5168 formatter.write_str("struct batch_plan.NestedLoopJoinNode")
5169 }
5170
5171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NestedLoopJoinNode, V::Error>
5172 where
5173 V: serde::de::MapAccess<'de>,
5174 {
5175 let mut join_type__ = None;
5176 let mut join_cond__ = None;
5177 let mut output_indices__ = None;
5178 while let Some(k) = map_.next_key()? {
5179 match k {
5180 GeneratedField::JoinType => {
5181 if join_type__.is_some() {
5182 return Err(serde::de::Error::duplicate_field("joinType"));
5183 }
5184 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5185 }
5186 GeneratedField::JoinCond => {
5187 if join_cond__.is_some() {
5188 return Err(serde::de::Error::duplicate_field("joinCond"));
5189 }
5190 join_cond__ = map_.next_value()?;
5191 }
5192 GeneratedField::OutputIndices => {
5193 if output_indices__.is_some() {
5194 return Err(serde::de::Error::duplicate_field("outputIndices"));
5195 }
5196 output_indices__ =
5197 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5198 .into_iter().map(|x| x.0).collect())
5199 ;
5200 }
5201 }
5202 }
5203 Ok(NestedLoopJoinNode {
5204 join_type: join_type__.unwrap_or_default(),
5205 join_cond: join_cond__,
5206 output_indices: output_indices__.unwrap_or_default(),
5207 })
5208 }
5209 }
5210 deserializer.deserialize_struct("batch_plan.NestedLoopJoinNode", FIELDS, GeneratedVisitor)
5211 }
5212}
5213impl serde::Serialize for PlanFragment {
5214 #[allow(deprecated)]
5215 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5216 where
5217 S: serde::Serializer,
5218 {
5219 use serde::ser::SerializeStruct;
5220 let mut len = 0;
5221 if self.root.is_some() {
5222 len += 1;
5223 }
5224 if self.exchange_info.is_some() {
5225 len += 1;
5226 }
5227 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanFragment", len)?;
5228 if let Some(v) = self.root.as_ref() {
5229 struct_ser.serialize_field("root", v)?;
5230 }
5231 if let Some(v) = self.exchange_info.as_ref() {
5232 struct_ser.serialize_field("exchangeInfo", v)?;
5233 }
5234 struct_ser.end()
5235 }
5236}
5237impl<'de> serde::Deserialize<'de> for PlanFragment {
5238 #[allow(deprecated)]
5239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5240 where
5241 D: serde::Deserializer<'de>,
5242 {
5243 const FIELDS: &[&str] = &[
5244 "root",
5245 "exchange_info",
5246 "exchangeInfo",
5247 ];
5248
5249 #[allow(clippy::enum_variant_names)]
5250 enum GeneratedField {
5251 Root,
5252 ExchangeInfo,
5253 }
5254 impl<'de> serde::Deserialize<'de> for GeneratedField {
5255 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5256 where
5257 D: serde::Deserializer<'de>,
5258 {
5259 struct GeneratedVisitor;
5260
5261 impl serde::de::Visitor<'_> for GeneratedVisitor {
5262 type Value = GeneratedField;
5263
5264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5265 write!(formatter, "expected one of: {:?}", &FIELDS)
5266 }
5267
5268 #[allow(unused_variables)]
5269 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5270 where
5271 E: serde::de::Error,
5272 {
5273 match value {
5274 "root" => Ok(GeneratedField::Root),
5275 "exchangeInfo" | "exchange_info" => Ok(GeneratedField::ExchangeInfo),
5276 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5277 }
5278 }
5279 }
5280 deserializer.deserialize_identifier(GeneratedVisitor)
5281 }
5282 }
5283 struct GeneratedVisitor;
5284 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5285 type Value = PlanFragment;
5286
5287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5288 formatter.write_str("struct batch_plan.PlanFragment")
5289 }
5290
5291 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanFragment, V::Error>
5292 where
5293 V: serde::de::MapAccess<'de>,
5294 {
5295 let mut root__ = None;
5296 let mut exchange_info__ = None;
5297 while let Some(k) = map_.next_key()? {
5298 match k {
5299 GeneratedField::Root => {
5300 if root__.is_some() {
5301 return Err(serde::de::Error::duplicate_field("root"));
5302 }
5303 root__ = map_.next_value()?;
5304 }
5305 GeneratedField::ExchangeInfo => {
5306 if exchange_info__.is_some() {
5307 return Err(serde::de::Error::duplicate_field("exchangeInfo"));
5308 }
5309 exchange_info__ = map_.next_value()?;
5310 }
5311 }
5312 }
5313 Ok(PlanFragment {
5314 root: root__,
5315 exchange_info: exchange_info__,
5316 })
5317 }
5318 }
5319 deserializer.deserialize_struct("batch_plan.PlanFragment", FIELDS, GeneratedVisitor)
5320 }
5321}
5322impl serde::Serialize for PlanNode {
5323 #[allow(deprecated)]
5324 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5325 where
5326 S: serde::Serializer,
5327 {
5328 use serde::ser::SerializeStruct;
5329 let mut len = 0;
5330 if !self.children.is_empty() {
5331 len += 1;
5332 }
5333 if !self.identity.is_empty() {
5334 len += 1;
5335 }
5336 if self.node_body.is_some() {
5337 len += 1;
5338 }
5339 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanNode", len)?;
5340 if !self.children.is_empty() {
5341 struct_ser.serialize_field("children", &self.children)?;
5342 }
5343 if !self.identity.is_empty() {
5344 struct_ser.serialize_field("identity", &self.identity)?;
5345 }
5346 if let Some(v) = self.node_body.as_ref() {
5347 match v {
5348 plan_node::NodeBody::Insert(v) => {
5349 struct_ser.serialize_field("insert", v)?;
5350 }
5351 plan_node::NodeBody::Delete(v) => {
5352 struct_ser.serialize_field("delete", v)?;
5353 }
5354 plan_node::NodeBody::Update(v) => {
5355 struct_ser.serialize_field("update", v)?;
5356 }
5357 plan_node::NodeBody::Project(v) => {
5358 struct_ser.serialize_field("project", v)?;
5359 }
5360 plan_node::NodeBody::HashAgg(v) => {
5361 struct_ser.serialize_field("hashAgg", v)?;
5362 }
5363 plan_node::NodeBody::Filter(v) => {
5364 struct_ser.serialize_field("filter", v)?;
5365 }
5366 plan_node::NodeBody::Exchange(v) => {
5367 struct_ser.serialize_field("exchange", v)?;
5368 }
5369 plan_node::NodeBody::Sort(v) => {
5370 struct_ser.serialize_field("sort", v)?;
5371 }
5372 plan_node::NodeBody::NestedLoopJoin(v) => {
5373 struct_ser.serialize_field("nestedLoopJoin", v)?;
5374 }
5375 plan_node::NodeBody::TopN(v) => {
5376 struct_ser.serialize_field("topN", v)?;
5377 }
5378 plan_node::NodeBody::SortAgg(v) => {
5379 struct_ser.serialize_field("sortAgg", v)?;
5380 }
5381 plan_node::NodeBody::RowSeqScan(v) => {
5382 struct_ser.serialize_field("rowSeqScan", v)?;
5383 }
5384 plan_node::NodeBody::Limit(v) => {
5385 struct_ser.serialize_field("limit", v)?;
5386 }
5387 plan_node::NodeBody::Values(v) => {
5388 struct_ser.serialize_field("values", v)?;
5389 }
5390 plan_node::NodeBody::HashJoin(v) => {
5391 struct_ser.serialize_field("hashJoin", v)?;
5392 }
5393 plan_node::NodeBody::MergeSortExchange(v) => {
5394 struct_ser.serialize_field("mergeSortExchange", v)?;
5395 }
5396 plan_node::NodeBody::HopWindow(v) => {
5397 struct_ser.serialize_field("hopWindow", v)?;
5398 }
5399 plan_node::NodeBody::TableFunction(v) => {
5400 struct_ser.serialize_field("tableFunction", v)?;
5401 }
5402 plan_node::NodeBody::SysRowSeqScan(v) => {
5403 struct_ser.serialize_field("sysRowSeqScan", v)?;
5404 }
5405 plan_node::NodeBody::Expand(v) => {
5406 struct_ser.serialize_field("expand", v)?;
5407 }
5408 plan_node::NodeBody::LocalLookupJoin(v) => {
5409 struct_ser.serialize_field("localLookupJoin", v)?;
5410 }
5411 plan_node::NodeBody::ProjectSet(v) => {
5412 struct_ser.serialize_field("projectSet", v)?;
5413 }
5414 plan_node::NodeBody::Union(v) => {
5415 struct_ser.serialize_field("union", v)?;
5416 }
5417 plan_node::NodeBody::GroupTopN(v) => {
5418 struct_ser.serialize_field("groupTopN", v)?;
5419 }
5420 plan_node::NodeBody::DistributedLookupJoin(v) => {
5421 struct_ser.serialize_field("distributedLookupJoin", v)?;
5422 }
5423 plan_node::NodeBody::Source(v) => {
5424 struct_ser.serialize_field("source", v)?;
5425 }
5426 plan_node::NodeBody::SortOverWindow(v) => {
5427 struct_ser.serialize_field("sortOverWindow", v)?;
5428 }
5429 plan_node::NodeBody::MaxOneRow(v) => {
5430 struct_ser.serialize_field("maxOneRow", v)?;
5431 }
5432 plan_node::NodeBody::LogRowSeqScan(v) => {
5433 struct_ser.serialize_field("logRowSeqScan", v)?;
5434 }
5435 plan_node::NodeBody::FileScan(v) => {
5436 struct_ser.serialize_field("fileScan", v)?;
5437 }
5438 plan_node::NodeBody::IcebergScan(v) => {
5439 struct_ser.serialize_field("icebergScan", v)?;
5440 }
5441 plan_node::NodeBody::PostgresQuery(v) => {
5442 struct_ser.serialize_field("postgresQuery", v)?;
5443 }
5444 plan_node::NodeBody::MysqlQuery(v) => {
5445 struct_ser.serialize_field("mysqlQuery", v)?;
5446 }
5447 plan_node::NodeBody::GcsFileScan(v) => {
5448 struct_ser.serialize_field("gcsFileScan", v)?;
5449 }
5450 plan_node::NodeBody::AzblobFileScan(v) => {
5451 struct_ser.serialize_field("azblobFileScan", v)?;
5452 }
5453 plan_node::NodeBody::VectorIndexNearest(v) => {
5454 struct_ser.serialize_field("vectorIndexNearest", v)?;
5455 }
5456 plan_node::NodeBody::GetChannelDeltaStats(v) => {
5457 struct_ser.serialize_field("getChannelDeltaStats", v)?;
5458 }
5459 plan_node::NodeBody::IcebergMetadataScan(v) => {
5460 struct_ser.serialize_field("icebergMetadataScan", v)?;
5461 }
5462 plan_node::NodeBody::BlockExecutor(v) => {
5463 struct_ser.serialize_field("blockExecutor", v)?;
5464 }
5465 plan_node::NodeBody::BusyLoopExecutor(v) => {
5466 struct_ser.serialize_field("busyLoopExecutor", v)?;
5467 }
5468 }
5469 }
5470 struct_ser.end()
5471 }
5472}
5473impl<'de> serde::Deserialize<'de> for PlanNode {
5474 #[allow(deprecated)]
5475 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5476 where
5477 D: serde::Deserializer<'de>,
5478 {
5479 const FIELDS: &[&str] = &[
5480 "children",
5481 "identity",
5482 "insert",
5483 "delete",
5484 "update",
5485 "project",
5486 "hash_agg",
5487 "hashAgg",
5488 "filter",
5489 "exchange",
5490 "sort",
5491 "nested_loop_join",
5492 "nestedLoopJoin",
5493 "top_n",
5494 "topN",
5495 "sort_agg",
5496 "sortAgg",
5497 "row_seq_scan",
5498 "rowSeqScan",
5499 "limit",
5500 "values",
5501 "hash_join",
5502 "hashJoin",
5503 "merge_sort_exchange",
5504 "mergeSortExchange",
5505 "hop_window",
5506 "hopWindow",
5507 "table_function",
5508 "tableFunction",
5509 "sys_row_seq_scan",
5510 "sysRowSeqScan",
5511 "expand",
5512 "local_lookup_join",
5513 "localLookupJoin",
5514 "project_set",
5515 "projectSet",
5516 "union",
5517 "group_top_n",
5518 "groupTopN",
5519 "distributed_lookup_join",
5520 "distributedLookupJoin",
5521 "source",
5522 "sort_over_window",
5523 "sortOverWindow",
5524 "max_one_row",
5525 "maxOneRow",
5526 "log_row_seq_scan",
5527 "logRowSeqScan",
5528 "file_scan",
5529 "fileScan",
5530 "iceberg_scan",
5531 "icebergScan",
5532 "postgres_query",
5533 "postgresQuery",
5534 "mysql_query",
5535 "mysqlQuery",
5536 "gcs_file_scan",
5537 "gcsFileScan",
5538 "azblob_file_scan",
5539 "azblobFileScan",
5540 "vector_index_nearest",
5541 "vectorIndexNearest",
5542 "get_channel_delta_stats",
5543 "getChannelDeltaStats",
5544 "iceberg_metadata_scan",
5545 "icebergMetadataScan",
5546 "block_executor",
5547 "blockExecutor",
5548 "busy_loop_executor",
5549 "busyLoopExecutor",
5550 ];
5551
5552 #[allow(clippy::enum_variant_names)]
5553 enum GeneratedField {
5554 Children,
5555 Identity,
5556 Insert,
5557 Delete,
5558 Update,
5559 Project,
5560 HashAgg,
5561 Filter,
5562 Exchange,
5563 Sort,
5564 NestedLoopJoin,
5565 TopN,
5566 SortAgg,
5567 RowSeqScan,
5568 Limit,
5569 Values,
5570 HashJoin,
5571 MergeSortExchange,
5572 HopWindow,
5573 TableFunction,
5574 SysRowSeqScan,
5575 Expand,
5576 LocalLookupJoin,
5577 ProjectSet,
5578 Union,
5579 GroupTopN,
5580 DistributedLookupJoin,
5581 Source,
5582 SortOverWindow,
5583 MaxOneRow,
5584 LogRowSeqScan,
5585 FileScan,
5586 IcebergScan,
5587 PostgresQuery,
5588 MysqlQuery,
5589 GcsFileScan,
5590 AzblobFileScan,
5591 VectorIndexNearest,
5592 GetChannelDeltaStats,
5593 IcebergMetadataScan,
5594 BlockExecutor,
5595 BusyLoopExecutor,
5596 }
5597 impl<'de> serde::Deserialize<'de> for GeneratedField {
5598 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5599 where
5600 D: serde::Deserializer<'de>,
5601 {
5602 struct GeneratedVisitor;
5603
5604 impl serde::de::Visitor<'_> for GeneratedVisitor {
5605 type Value = GeneratedField;
5606
5607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5608 write!(formatter, "expected one of: {:?}", &FIELDS)
5609 }
5610
5611 #[allow(unused_variables)]
5612 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5613 where
5614 E: serde::de::Error,
5615 {
5616 match value {
5617 "children" => Ok(GeneratedField::Children),
5618 "identity" => Ok(GeneratedField::Identity),
5619 "insert" => Ok(GeneratedField::Insert),
5620 "delete" => Ok(GeneratedField::Delete),
5621 "update" => Ok(GeneratedField::Update),
5622 "project" => Ok(GeneratedField::Project),
5623 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
5624 "filter" => Ok(GeneratedField::Filter),
5625 "exchange" => Ok(GeneratedField::Exchange),
5626 "sort" => Ok(GeneratedField::Sort),
5627 "nestedLoopJoin" | "nested_loop_join" => Ok(GeneratedField::NestedLoopJoin),
5628 "topN" | "top_n" => Ok(GeneratedField::TopN),
5629 "sortAgg" | "sort_agg" => Ok(GeneratedField::SortAgg),
5630 "rowSeqScan" | "row_seq_scan" => Ok(GeneratedField::RowSeqScan),
5631 "limit" => Ok(GeneratedField::Limit),
5632 "values" => Ok(GeneratedField::Values),
5633 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
5634 "mergeSortExchange" | "merge_sort_exchange" => Ok(GeneratedField::MergeSortExchange),
5635 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
5636 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
5637 "sysRowSeqScan" | "sys_row_seq_scan" => Ok(GeneratedField::SysRowSeqScan),
5638 "expand" => Ok(GeneratedField::Expand),
5639 "localLookupJoin" | "local_lookup_join" => Ok(GeneratedField::LocalLookupJoin),
5640 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
5641 "union" => Ok(GeneratedField::Union),
5642 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
5643 "distributedLookupJoin" | "distributed_lookup_join" => Ok(GeneratedField::DistributedLookupJoin),
5644 "source" => Ok(GeneratedField::Source),
5645 "sortOverWindow" | "sort_over_window" => Ok(GeneratedField::SortOverWindow),
5646 "maxOneRow" | "max_one_row" => Ok(GeneratedField::MaxOneRow),
5647 "logRowSeqScan" | "log_row_seq_scan" => Ok(GeneratedField::LogRowSeqScan),
5648 "fileScan" | "file_scan" => Ok(GeneratedField::FileScan),
5649 "icebergScan" | "iceberg_scan" => Ok(GeneratedField::IcebergScan),
5650 "postgresQuery" | "postgres_query" => Ok(GeneratedField::PostgresQuery),
5651 "mysqlQuery" | "mysql_query" => Ok(GeneratedField::MysqlQuery),
5652 "gcsFileScan" | "gcs_file_scan" => Ok(GeneratedField::GcsFileScan),
5653 "azblobFileScan" | "azblob_file_scan" => Ok(GeneratedField::AzblobFileScan),
5654 "vectorIndexNearest" | "vector_index_nearest" => Ok(GeneratedField::VectorIndexNearest),
5655 "getChannelDeltaStats" | "get_channel_delta_stats" => Ok(GeneratedField::GetChannelDeltaStats),
5656 "icebergMetadataScan" | "iceberg_metadata_scan" => Ok(GeneratedField::IcebergMetadataScan),
5657 "blockExecutor" | "block_executor" => Ok(GeneratedField::BlockExecutor),
5658 "busyLoopExecutor" | "busy_loop_executor" => Ok(GeneratedField::BusyLoopExecutor),
5659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5660 }
5661 }
5662 }
5663 deserializer.deserialize_identifier(GeneratedVisitor)
5664 }
5665 }
5666 struct GeneratedVisitor;
5667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5668 type Value = PlanNode;
5669
5670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5671 formatter.write_str("struct batch_plan.PlanNode")
5672 }
5673
5674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanNode, V::Error>
5675 where
5676 V: serde::de::MapAccess<'de>,
5677 {
5678 let mut children__ = None;
5679 let mut identity__ = None;
5680 let mut node_body__ = None;
5681 while let Some(k) = map_.next_key()? {
5682 match k {
5683 GeneratedField::Children => {
5684 if children__.is_some() {
5685 return Err(serde::de::Error::duplicate_field("children"));
5686 }
5687 children__ = Some(map_.next_value()?);
5688 }
5689 GeneratedField::Identity => {
5690 if identity__.is_some() {
5691 return Err(serde::de::Error::duplicate_field("identity"));
5692 }
5693 identity__ = Some(map_.next_value()?);
5694 }
5695 GeneratedField::Insert => {
5696 if node_body__.is_some() {
5697 return Err(serde::de::Error::duplicate_field("insert"));
5698 }
5699 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Insert)
5700;
5701 }
5702 GeneratedField::Delete => {
5703 if node_body__.is_some() {
5704 return Err(serde::de::Error::duplicate_field("delete"));
5705 }
5706 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Delete)
5707;
5708 }
5709 GeneratedField::Update => {
5710 if node_body__.is_some() {
5711 return Err(serde::de::Error::duplicate_field("update"));
5712 }
5713 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Update)
5714;
5715 }
5716 GeneratedField::Project => {
5717 if node_body__.is_some() {
5718 return Err(serde::de::Error::duplicate_field("project"));
5719 }
5720 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Project)
5721;
5722 }
5723 GeneratedField::HashAgg => {
5724 if node_body__.is_some() {
5725 return Err(serde::de::Error::duplicate_field("hashAgg"));
5726 }
5727 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashAgg)
5728;
5729 }
5730 GeneratedField::Filter => {
5731 if node_body__.is_some() {
5732 return Err(serde::de::Error::duplicate_field("filter"));
5733 }
5734 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Filter)
5735;
5736 }
5737 GeneratedField::Exchange => {
5738 if node_body__.is_some() {
5739 return Err(serde::de::Error::duplicate_field("exchange"));
5740 }
5741 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Exchange)
5742;
5743 }
5744 GeneratedField::Sort => {
5745 if node_body__.is_some() {
5746 return Err(serde::de::Error::duplicate_field("sort"));
5747 }
5748 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Sort)
5749;
5750 }
5751 GeneratedField::NestedLoopJoin => {
5752 if node_body__.is_some() {
5753 return Err(serde::de::Error::duplicate_field("nestedLoopJoin"));
5754 }
5755 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::NestedLoopJoin)
5756;
5757 }
5758 GeneratedField::TopN => {
5759 if node_body__.is_some() {
5760 return Err(serde::de::Error::duplicate_field("topN"));
5761 }
5762 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TopN)
5763;
5764 }
5765 GeneratedField::SortAgg => {
5766 if node_body__.is_some() {
5767 return Err(serde::de::Error::duplicate_field("sortAgg"));
5768 }
5769 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortAgg)
5770;
5771 }
5772 GeneratedField::RowSeqScan => {
5773 if node_body__.is_some() {
5774 return Err(serde::de::Error::duplicate_field("rowSeqScan"));
5775 }
5776 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::RowSeqScan)
5777;
5778 }
5779 GeneratedField::Limit => {
5780 if node_body__.is_some() {
5781 return Err(serde::de::Error::duplicate_field("limit"));
5782 }
5783 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Limit)
5784;
5785 }
5786 GeneratedField::Values => {
5787 if node_body__.is_some() {
5788 return Err(serde::de::Error::duplicate_field("values"));
5789 }
5790 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Values)
5791;
5792 }
5793 GeneratedField::HashJoin => {
5794 if node_body__.is_some() {
5795 return Err(serde::de::Error::duplicate_field("hashJoin"));
5796 }
5797 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashJoin)
5798;
5799 }
5800 GeneratedField::MergeSortExchange => {
5801 if node_body__.is_some() {
5802 return Err(serde::de::Error::duplicate_field("mergeSortExchange"));
5803 }
5804 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MergeSortExchange)
5805;
5806 }
5807 GeneratedField::HopWindow => {
5808 if node_body__.is_some() {
5809 return Err(serde::de::Error::duplicate_field("hopWindow"));
5810 }
5811 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HopWindow)
5812;
5813 }
5814 GeneratedField::TableFunction => {
5815 if node_body__.is_some() {
5816 return Err(serde::de::Error::duplicate_field("tableFunction"));
5817 }
5818 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TableFunction)
5819;
5820 }
5821 GeneratedField::SysRowSeqScan => {
5822 if node_body__.is_some() {
5823 return Err(serde::de::Error::duplicate_field("sysRowSeqScan"));
5824 }
5825 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SysRowSeqScan)
5826;
5827 }
5828 GeneratedField::Expand => {
5829 if node_body__.is_some() {
5830 return Err(serde::de::Error::duplicate_field("expand"));
5831 }
5832 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Expand)
5833;
5834 }
5835 GeneratedField::LocalLookupJoin => {
5836 if node_body__.is_some() {
5837 return Err(serde::de::Error::duplicate_field("localLookupJoin"));
5838 }
5839 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LocalLookupJoin)
5840;
5841 }
5842 GeneratedField::ProjectSet => {
5843 if node_body__.is_some() {
5844 return Err(serde::de::Error::duplicate_field("projectSet"));
5845 }
5846 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::ProjectSet)
5847;
5848 }
5849 GeneratedField::Union => {
5850 if node_body__.is_some() {
5851 return Err(serde::de::Error::duplicate_field("union"));
5852 }
5853 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Union)
5854;
5855 }
5856 GeneratedField::GroupTopN => {
5857 if node_body__.is_some() {
5858 return Err(serde::de::Error::duplicate_field("groupTopN"));
5859 }
5860 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GroupTopN)
5861;
5862 }
5863 GeneratedField::DistributedLookupJoin => {
5864 if node_body__.is_some() {
5865 return Err(serde::de::Error::duplicate_field("distributedLookupJoin"));
5866 }
5867 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::DistributedLookupJoin)
5868;
5869 }
5870 GeneratedField::Source => {
5871 if node_body__.is_some() {
5872 return Err(serde::de::Error::duplicate_field("source"));
5873 }
5874 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Source)
5875;
5876 }
5877 GeneratedField::SortOverWindow => {
5878 if node_body__.is_some() {
5879 return Err(serde::de::Error::duplicate_field("sortOverWindow"));
5880 }
5881 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortOverWindow)
5882;
5883 }
5884 GeneratedField::MaxOneRow => {
5885 if node_body__.is_some() {
5886 return Err(serde::de::Error::duplicate_field("maxOneRow"));
5887 }
5888 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MaxOneRow)
5889;
5890 }
5891 GeneratedField::LogRowSeqScan => {
5892 if node_body__.is_some() {
5893 return Err(serde::de::Error::duplicate_field("logRowSeqScan"));
5894 }
5895 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LogRowSeqScan)
5896;
5897 }
5898 GeneratedField::FileScan => {
5899 if node_body__.is_some() {
5900 return Err(serde::de::Error::duplicate_field("fileScan"));
5901 }
5902 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::FileScan)
5903;
5904 }
5905 GeneratedField::IcebergScan => {
5906 if node_body__.is_some() {
5907 return Err(serde::de::Error::duplicate_field("icebergScan"));
5908 }
5909 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergScan)
5910;
5911 }
5912 GeneratedField::PostgresQuery => {
5913 if node_body__.is_some() {
5914 return Err(serde::de::Error::duplicate_field("postgresQuery"));
5915 }
5916 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::PostgresQuery)
5917;
5918 }
5919 GeneratedField::MysqlQuery => {
5920 if node_body__.is_some() {
5921 return Err(serde::de::Error::duplicate_field("mysqlQuery"));
5922 }
5923 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MysqlQuery)
5924;
5925 }
5926 GeneratedField::GcsFileScan => {
5927 if node_body__.is_some() {
5928 return Err(serde::de::Error::duplicate_field("gcsFileScan"));
5929 }
5930 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GcsFileScan)
5931;
5932 }
5933 GeneratedField::AzblobFileScan => {
5934 if node_body__.is_some() {
5935 return Err(serde::de::Error::duplicate_field("azblobFileScan"));
5936 }
5937 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::AzblobFileScan)
5938;
5939 }
5940 GeneratedField::VectorIndexNearest => {
5941 if node_body__.is_some() {
5942 return Err(serde::de::Error::duplicate_field("vectorIndexNearest"));
5943 }
5944 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::VectorIndexNearest)
5945;
5946 }
5947 GeneratedField::GetChannelDeltaStats => {
5948 if node_body__.is_some() {
5949 return Err(serde::de::Error::duplicate_field("getChannelDeltaStats"));
5950 }
5951 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GetChannelDeltaStats)
5952;
5953 }
5954 GeneratedField::IcebergMetadataScan => {
5955 if node_body__.is_some() {
5956 return Err(serde::de::Error::duplicate_field("icebergMetadataScan"));
5957 }
5958 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergMetadataScan)
5959;
5960 }
5961 GeneratedField::BlockExecutor => {
5962 if node_body__.is_some() {
5963 return Err(serde::de::Error::duplicate_field("blockExecutor"));
5964 }
5965 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BlockExecutor);
5966 }
5967 GeneratedField::BusyLoopExecutor => {
5968 if node_body__.is_some() {
5969 return Err(serde::de::Error::duplicate_field("busyLoopExecutor"));
5970 }
5971 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BusyLoopExecutor);
5972 }
5973 }
5974 }
5975 Ok(PlanNode {
5976 children: children__.unwrap_or_default(),
5977 identity: identity__.unwrap_or_default(),
5978 node_body: node_body__,
5979 })
5980 }
5981 }
5982 deserializer.deserialize_struct("batch_plan.PlanNode", FIELDS, GeneratedVisitor)
5983 }
5984}
5985impl serde::Serialize for PostgresQueryNode {
5986 #[allow(deprecated)]
5987 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5988 where
5989 S: serde::Serializer,
5990 {
5991 use serde::ser::SerializeStruct;
5992 let mut len = 0;
5993 if !self.columns.is_empty() {
5994 len += 1;
5995 }
5996 if !self.hostname.is_empty() {
5997 len += 1;
5998 }
5999 if !self.port.is_empty() {
6000 len += 1;
6001 }
6002 if !self.username.is_empty() {
6003 len += 1;
6004 }
6005 if !self.password.is_empty() {
6006 len += 1;
6007 }
6008 if !self.database.is_empty() {
6009 len += 1;
6010 }
6011 if !self.query.is_empty() {
6012 len += 1;
6013 }
6014 if !self.ssl_mode.is_empty() {
6015 len += 1;
6016 }
6017 if !self.ssl_root_cert.is_empty() {
6018 len += 1;
6019 }
6020 let mut struct_ser = serializer.serialize_struct("batch_plan.PostgresQueryNode", len)?;
6021 if !self.columns.is_empty() {
6022 struct_ser.serialize_field("columns", &self.columns)?;
6023 }
6024 if !self.hostname.is_empty() {
6025 struct_ser.serialize_field("hostname", &self.hostname)?;
6026 }
6027 if !self.port.is_empty() {
6028 struct_ser.serialize_field("port", &self.port)?;
6029 }
6030 if !self.username.is_empty() {
6031 struct_ser.serialize_field("username", &self.username)?;
6032 }
6033 if !self.password.is_empty() {
6034 struct_ser.serialize_field("password", &self.password)?;
6035 }
6036 if !self.database.is_empty() {
6037 struct_ser.serialize_field("database", &self.database)?;
6038 }
6039 if !self.query.is_empty() {
6040 struct_ser.serialize_field("query", &self.query)?;
6041 }
6042 if !self.ssl_mode.is_empty() {
6043 struct_ser.serialize_field("sslMode", &self.ssl_mode)?;
6044 }
6045 if !self.ssl_root_cert.is_empty() {
6046 struct_ser.serialize_field("sslRootCert", &self.ssl_root_cert)?;
6047 }
6048 struct_ser.end()
6049 }
6050}
6051impl<'de> serde::Deserialize<'de> for PostgresQueryNode {
6052 #[allow(deprecated)]
6053 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6054 where
6055 D: serde::Deserializer<'de>,
6056 {
6057 const FIELDS: &[&str] = &[
6058 "columns",
6059 "hostname",
6060 "port",
6061 "username",
6062 "password",
6063 "database",
6064 "query",
6065 "ssl_mode",
6066 "sslMode",
6067 "ssl_root_cert",
6068 "sslRootCert",
6069 ];
6070
6071 #[allow(clippy::enum_variant_names)]
6072 enum GeneratedField {
6073 Columns,
6074 Hostname,
6075 Port,
6076 Username,
6077 Password,
6078 Database,
6079 Query,
6080 SslMode,
6081 SslRootCert,
6082 }
6083 impl<'de> serde::Deserialize<'de> for GeneratedField {
6084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6085 where
6086 D: serde::Deserializer<'de>,
6087 {
6088 struct GeneratedVisitor;
6089
6090 impl serde::de::Visitor<'_> for GeneratedVisitor {
6091 type Value = GeneratedField;
6092
6093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6094 write!(formatter, "expected one of: {:?}", &FIELDS)
6095 }
6096
6097 #[allow(unused_variables)]
6098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6099 where
6100 E: serde::de::Error,
6101 {
6102 match value {
6103 "columns" => Ok(GeneratedField::Columns),
6104 "hostname" => Ok(GeneratedField::Hostname),
6105 "port" => Ok(GeneratedField::Port),
6106 "username" => Ok(GeneratedField::Username),
6107 "password" => Ok(GeneratedField::Password),
6108 "database" => Ok(GeneratedField::Database),
6109 "query" => Ok(GeneratedField::Query),
6110 "sslMode" | "ssl_mode" => Ok(GeneratedField::SslMode),
6111 "sslRootCert" | "ssl_root_cert" => Ok(GeneratedField::SslRootCert),
6112 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6113 }
6114 }
6115 }
6116 deserializer.deserialize_identifier(GeneratedVisitor)
6117 }
6118 }
6119 struct GeneratedVisitor;
6120 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6121 type Value = PostgresQueryNode;
6122
6123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6124 formatter.write_str("struct batch_plan.PostgresQueryNode")
6125 }
6126
6127 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PostgresQueryNode, V::Error>
6128 where
6129 V: serde::de::MapAccess<'de>,
6130 {
6131 let mut columns__ = None;
6132 let mut hostname__ = None;
6133 let mut port__ = None;
6134 let mut username__ = None;
6135 let mut password__ = None;
6136 let mut database__ = None;
6137 let mut query__ = None;
6138 let mut ssl_mode__ = None;
6139 let mut ssl_root_cert__ = None;
6140 while let Some(k) = map_.next_key()? {
6141 match k {
6142 GeneratedField::Columns => {
6143 if columns__.is_some() {
6144 return Err(serde::de::Error::duplicate_field("columns"));
6145 }
6146 columns__ = Some(map_.next_value()?);
6147 }
6148 GeneratedField::Hostname => {
6149 if hostname__.is_some() {
6150 return Err(serde::de::Error::duplicate_field("hostname"));
6151 }
6152 hostname__ = Some(map_.next_value()?);
6153 }
6154 GeneratedField::Port => {
6155 if port__.is_some() {
6156 return Err(serde::de::Error::duplicate_field("port"));
6157 }
6158 port__ = Some(map_.next_value()?);
6159 }
6160 GeneratedField::Username => {
6161 if username__.is_some() {
6162 return Err(serde::de::Error::duplicate_field("username"));
6163 }
6164 username__ = Some(map_.next_value()?);
6165 }
6166 GeneratedField::Password => {
6167 if password__.is_some() {
6168 return Err(serde::de::Error::duplicate_field("password"));
6169 }
6170 password__ = Some(map_.next_value()?);
6171 }
6172 GeneratedField::Database => {
6173 if database__.is_some() {
6174 return Err(serde::de::Error::duplicate_field("database"));
6175 }
6176 database__ = Some(map_.next_value()?);
6177 }
6178 GeneratedField::Query => {
6179 if query__.is_some() {
6180 return Err(serde::de::Error::duplicate_field("query"));
6181 }
6182 query__ = Some(map_.next_value()?);
6183 }
6184 GeneratedField::SslMode => {
6185 if ssl_mode__.is_some() {
6186 return Err(serde::de::Error::duplicate_field("sslMode"));
6187 }
6188 ssl_mode__ = Some(map_.next_value()?);
6189 }
6190 GeneratedField::SslRootCert => {
6191 if ssl_root_cert__.is_some() {
6192 return Err(serde::de::Error::duplicate_field("sslRootCert"));
6193 }
6194 ssl_root_cert__ = Some(map_.next_value()?);
6195 }
6196 }
6197 }
6198 Ok(PostgresQueryNode {
6199 columns: columns__.unwrap_or_default(),
6200 hostname: hostname__.unwrap_or_default(),
6201 port: port__.unwrap_or_default(),
6202 username: username__.unwrap_or_default(),
6203 password: password__.unwrap_or_default(),
6204 database: database__.unwrap_or_default(),
6205 query: query__.unwrap_or_default(),
6206 ssl_mode: ssl_mode__.unwrap_or_default(),
6207 ssl_root_cert: ssl_root_cert__.unwrap_or_default(),
6208 })
6209 }
6210 }
6211 deserializer.deserialize_struct("batch_plan.PostgresQueryNode", FIELDS, GeneratedVisitor)
6212 }
6213}
6214impl serde::Serialize for ProjectNode {
6215 #[allow(deprecated)]
6216 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6217 where
6218 S: serde::Serializer,
6219 {
6220 use serde::ser::SerializeStruct;
6221 let mut len = 0;
6222 if !self.select_list.is_empty() {
6223 len += 1;
6224 }
6225 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectNode", len)?;
6226 if !self.select_list.is_empty() {
6227 struct_ser.serialize_field("selectList", &self.select_list)?;
6228 }
6229 struct_ser.end()
6230 }
6231}
6232impl<'de> serde::Deserialize<'de> for ProjectNode {
6233 #[allow(deprecated)]
6234 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6235 where
6236 D: serde::Deserializer<'de>,
6237 {
6238 const FIELDS: &[&str] = &[
6239 "select_list",
6240 "selectList",
6241 ];
6242
6243 #[allow(clippy::enum_variant_names)]
6244 enum GeneratedField {
6245 SelectList,
6246 }
6247 impl<'de> serde::Deserialize<'de> for GeneratedField {
6248 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6249 where
6250 D: serde::Deserializer<'de>,
6251 {
6252 struct GeneratedVisitor;
6253
6254 impl serde::de::Visitor<'_> for GeneratedVisitor {
6255 type Value = GeneratedField;
6256
6257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6258 write!(formatter, "expected one of: {:?}", &FIELDS)
6259 }
6260
6261 #[allow(unused_variables)]
6262 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6263 where
6264 E: serde::de::Error,
6265 {
6266 match value {
6267 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
6268 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6269 }
6270 }
6271 }
6272 deserializer.deserialize_identifier(GeneratedVisitor)
6273 }
6274 }
6275 struct GeneratedVisitor;
6276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6277 type Value = ProjectNode;
6278
6279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6280 formatter.write_str("struct batch_plan.ProjectNode")
6281 }
6282
6283 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
6284 where
6285 V: serde::de::MapAccess<'de>,
6286 {
6287 let mut select_list__ = None;
6288 while let Some(k) = map_.next_key()? {
6289 match k {
6290 GeneratedField::SelectList => {
6291 if select_list__.is_some() {
6292 return Err(serde::de::Error::duplicate_field("selectList"));
6293 }
6294 select_list__ = Some(map_.next_value()?);
6295 }
6296 }
6297 }
6298 Ok(ProjectNode {
6299 select_list: select_list__.unwrap_or_default(),
6300 })
6301 }
6302 }
6303 deserializer.deserialize_struct("batch_plan.ProjectNode", FIELDS, GeneratedVisitor)
6304 }
6305}
6306impl serde::Serialize for ProjectSetNode {
6307 #[allow(deprecated)]
6308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6309 where
6310 S: serde::Serializer,
6311 {
6312 use serde::ser::SerializeStruct;
6313 let mut len = 0;
6314 if !self.select_list.is_empty() {
6315 len += 1;
6316 }
6317 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectSetNode", len)?;
6318 if !self.select_list.is_empty() {
6319 struct_ser.serialize_field("selectList", &self.select_list)?;
6320 }
6321 struct_ser.end()
6322 }
6323}
6324impl<'de> serde::Deserialize<'de> for ProjectSetNode {
6325 #[allow(deprecated)]
6326 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6327 where
6328 D: serde::Deserializer<'de>,
6329 {
6330 const FIELDS: &[&str] = &[
6331 "select_list",
6332 "selectList",
6333 ];
6334
6335 #[allow(clippy::enum_variant_names)]
6336 enum GeneratedField {
6337 SelectList,
6338 }
6339 impl<'de> serde::Deserialize<'de> for GeneratedField {
6340 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6341 where
6342 D: serde::Deserializer<'de>,
6343 {
6344 struct GeneratedVisitor;
6345
6346 impl serde::de::Visitor<'_> for GeneratedVisitor {
6347 type Value = GeneratedField;
6348
6349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6350 write!(formatter, "expected one of: {:?}", &FIELDS)
6351 }
6352
6353 #[allow(unused_variables)]
6354 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6355 where
6356 E: serde::de::Error,
6357 {
6358 match value {
6359 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
6360 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6361 }
6362 }
6363 }
6364 deserializer.deserialize_identifier(GeneratedVisitor)
6365 }
6366 }
6367 struct GeneratedVisitor;
6368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6369 type Value = ProjectSetNode;
6370
6371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6372 formatter.write_str("struct batch_plan.ProjectSetNode")
6373 }
6374
6375 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
6376 where
6377 V: serde::de::MapAccess<'de>,
6378 {
6379 let mut select_list__ = None;
6380 while let Some(k) = map_.next_key()? {
6381 match k {
6382 GeneratedField::SelectList => {
6383 if select_list__.is_some() {
6384 return Err(serde::de::Error::duplicate_field("selectList"));
6385 }
6386 select_list__ = Some(map_.next_value()?);
6387 }
6388 }
6389 }
6390 Ok(ProjectSetNode {
6391 select_list: select_list__.unwrap_or_default(),
6392 })
6393 }
6394 }
6395 deserializer.deserialize_struct("batch_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
6396 }
6397}
6398impl serde::Serialize for RowSeqScanNode {
6399 #[allow(deprecated)]
6400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6401 where
6402 S: serde::Serializer,
6403 {
6404 use serde::ser::SerializeStruct;
6405 let mut len = 0;
6406 if self.table_desc.is_some() {
6407 len += 1;
6408 }
6409 if !self.column_ids.is_empty() {
6410 len += 1;
6411 }
6412 if !self.scan_ranges.is_empty() {
6413 len += 1;
6414 }
6415 if self.vnode_bitmap.is_some() {
6416 len += 1;
6417 }
6418 if self.ordered {
6419 len += 1;
6420 }
6421 if self.limit.is_some() {
6422 len += 1;
6423 }
6424 if self.query_epoch.is_some() {
6425 len += 1;
6426 }
6427 let mut struct_ser = serializer.serialize_struct("batch_plan.RowSeqScanNode", len)?;
6428 if let Some(v) = self.table_desc.as_ref() {
6429 struct_ser.serialize_field("tableDesc", v)?;
6430 }
6431 if !self.column_ids.is_empty() {
6432 struct_ser.serialize_field("columnIds", &self.column_ids)?;
6433 }
6434 if !self.scan_ranges.is_empty() {
6435 struct_ser.serialize_field("scanRanges", &self.scan_ranges)?;
6436 }
6437 if let Some(v) = self.vnode_bitmap.as_ref() {
6438 struct_ser.serialize_field("vnodeBitmap", v)?;
6439 }
6440 if self.ordered {
6441 struct_ser.serialize_field("ordered", &self.ordered)?;
6442 }
6443 if let Some(v) = self.limit.as_ref() {
6444 #[allow(clippy::needless_borrow)]
6445 #[allow(clippy::needless_borrows_for_generic_args)]
6446 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
6447 }
6448 if let Some(v) = self.query_epoch.as_ref() {
6449 struct_ser.serialize_field("queryEpoch", v)?;
6450 }
6451 struct_ser.end()
6452 }
6453}
6454impl<'de> serde::Deserialize<'de> for RowSeqScanNode {
6455 #[allow(deprecated)]
6456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6457 where
6458 D: serde::Deserializer<'de>,
6459 {
6460 const FIELDS: &[&str] = &[
6461 "table_desc",
6462 "tableDesc",
6463 "column_ids",
6464 "columnIds",
6465 "scan_ranges",
6466 "scanRanges",
6467 "vnode_bitmap",
6468 "vnodeBitmap",
6469 "ordered",
6470 "limit",
6471 "query_epoch",
6472 "queryEpoch",
6473 ];
6474
6475 #[allow(clippy::enum_variant_names)]
6476 enum GeneratedField {
6477 TableDesc,
6478 ColumnIds,
6479 ScanRanges,
6480 VnodeBitmap,
6481 Ordered,
6482 Limit,
6483 QueryEpoch,
6484 }
6485 impl<'de> serde::Deserialize<'de> for GeneratedField {
6486 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6487 where
6488 D: serde::Deserializer<'de>,
6489 {
6490 struct GeneratedVisitor;
6491
6492 impl serde::de::Visitor<'_> for GeneratedVisitor {
6493 type Value = GeneratedField;
6494
6495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6496 write!(formatter, "expected one of: {:?}", &FIELDS)
6497 }
6498
6499 #[allow(unused_variables)]
6500 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6501 where
6502 E: serde::de::Error,
6503 {
6504 match value {
6505 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
6506 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
6507 "scanRanges" | "scan_ranges" => Ok(GeneratedField::ScanRanges),
6508 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
6509 "ordered" => Ok(GeneratedField::Ordered),
6510 "limit" => Ok(GeneratedField::Limit),
6511 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
6512 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6513 }
6514 }
6515 }
6516 deserializer.deserialize_identifier(GeneratedVisitor)
6517 }
6518 }
6519 struct GeneratedVisitor;
6520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6521 type Value = RowSeqScanNode;
6522
6523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6524 formatter.write_str("struct batch_plan.RowSeqScanNode")
6525 }
6526
6527 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowSeqScanNode, V::Error>
6528 where
6529 V: serde::de::MapAccess<'de>,
6530 {
6531 let mut table_desc__ = None;
6532 let mut column_ids__ = None;
6533 let mut scan_ranges__ = None;
6534 let mut vnode_bitmap__ = None;
6535 let mut ordered__ = None;
6536 let mut limit__ = None;
6537 let mut query_epoch__ = None;
6538 while let Some(k) = map_.next_key()? {
6539 match k {
6540 GeneratedField::TableDesc => {
6541 if table_desc__.is_some() {
6542 return Err(serde::de::Error::duplicate_field("tableDesc"));
6543 }
6544 table_desc__ = map_.next_value()?;
6545 }
6546 GeneratedField::ColumnIds => {
6547 if column_ids__.is_some() {
6548 return Err(serde::de::Error::duplicate_field("columnIds"));
6549 }
6550 column_ids__ =
6551 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6552 .into_iter().map(|x| x.0).collect())
6553 ;
6554 }
6555 GeneratedField::ScanRanges => {
6556 if scan_ranges__.is_some() {
6557 return Err(serde::de::Error::duplicate_field("scanRanges"));
6558 }
6559 scan_ranges__ = Some(map_.next_value()?);
6560 }
6561 GeneratedField::VnodeBitmap => {
6562 if vnode_bitmap__.is_some() {
6563 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
6564 }
6565 vnode_bitmap__ = map_.next_value()?;
6566 }
6567 GeneratedField::Ordered => {
6568 if ordered__.is_some() {
6569 return Err(serde::de::Error::duplicate_field("ordered"));
6570 }
6571 ordered__ = Some(map_.next_value()?);
6572 }
6573 GeneratedField::Limit => {
6574 if limit__.is_some() {
6575 return Err(serde::de::Error::duplicate_field("limit"));
6576 }
6577 limit__ =
6578 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6579 ;
6580 }
6581 GeneratedField::QueryEpoch => {
6582 if query_epoch__.is_some() {
6583 return Err(serde::de::Error::duplicate_field("queryEpoch"));
6584 }
6585 query_epoch__ = map_.next_value()?;
6586 }
6587 }
6588 }
6589 Ok(RowSeqScanNode {
6590 table_desc: table_desc__,
6591 column_ids: column_ids__.unwrap_or_default(),
6592 scan_ranges: scan_ranges__.unwrap_or_default(),
6593 vnode_bitmap: vnode_bitmap__,
6594 ordered: ordered__.unwrap_or_default(),
6595 limit: limit__,
6596 query_epoch: query_epoch__,
6597 })
6598 }
6599 }
6600 deserializer.deserialize_struct("batch_plan.RowSeqScanNode", FIELDS, GeneratedVisitor)
6601 }
6602}
6603impl serde::Serialize for ScanRange {
6604 #[allow(deprecated)]
6605 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6606 where
6607 S: serde::Serializer,
6608 {
6609 use serde::ser::SerializeStruct;
6610 let mut len = 0;
6611 if !self.eq_conds.is_empty() {
6612 len += 1;
6613 }
6614 if self.lower_bound.is_some() {
6615 len += 1;
6616 }
6617 if self.upper_bound.is_some() {
6618 len += 1;
6619 }
6620 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange", len)?;
6621 if !self.eq_conds.is_empty() {
6622 struct_ser.serialize_field("eqConds", &self.eq_conds.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6623 }
6624 if let Some(v) = self.lower_bound.as_ref() {
6625 struct_ser.serialize_field("lowerBound", v)?;
6626 }
6627 if let Some(v) = self.upper_bound.as_ref() {
6628 struct_ser.serialize_field("upperBound", v)?;
6629 }
6630 struct_ser.end()
6631 }
6632}
6633impl<'de> serde::Deserialize<'de> for ScanRange {
6634 #[allow(deprecated)]
6635 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6636 where
6637 D: serde::Deserializer<'de>,
6638 {
6639 const FIELDS: &[&str] = &[
6640 "eq_conds",
6641 "eqConds",
6642 "lower_bound",
6643 "lowerBound",
6644 "upper_bound",
6645 "upperBound",
6646 ];
6647
6648 #[allow(clippy::enum_variant_names)]
6649 enum GeneratedField {
6650 EqConds,
6651 LowerBound,
6652 UpperBound,
6653 }
6654 impl<'de> serde::Deserialize<'de> for GeneratedField {
6655 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6656 where
6657 D: serde::Deserializer<'de>,
6658 {
6659 struct GeneratedVisitor;
6660
6661 impl serde::de::Visitor<'_> for GeneratedVisitor {
6662 type Value = GeneratedField;
6663
6664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6665 write!(formatter, "expected one of: {:?}", &FIELDS)
6666 }
6667
6668 #[allow(unused_variables)]
6669 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6670 where
6671 E: serde::de::Error,
6672 {
6673 match value {
6674 "eqConds" | "eq_conds" => Ok(GeneratedField::EqConds),
6675 "lowerBound" | "lower_bound" => Ok(GeneratedField::LowerBound),
6676 "upperBound" | "upper_bound" => Ok(GeneratedField::UpperBound),
6677 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6678 }
6679 }
6680 }
6681 deserializer.deserialize_identifier(GeneratedVisitor)
6682 }
6683 }
6684 struct GeneratedVisitor;
6685 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6686 type Value = ScanRange;
6687
6688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6689 formatter.write_str("struct batch_plan.ScanRange")
6690 }
6691
6692 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScanRange, V::Error>
6693 where
6694 V: serde::de::MapAccess<'de>,
6695 {
6696 let mut eq_conds__ = None;
6697 let mut lower_bound__ = None;
6698 let mut upper_bound__ = None;
6699 while let Some(k) = map_.next_key()? {
6700 match k {
6701 GeneratedField::EqConds => {
6702 if eq_conds__.is_some() {
6703 return Err(serde::de::Error::duplicate_field("eqConds"));
6704 }
6705 eq_conds__ =
6706 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6707 .into_iter().map(|x| x.0).collect())
6708 ;
6709 }
6710 GeneratedField::LowerBound => {
6711 if lower_bound__.is_some() {
6712 return Err(serde::de::Error::duplicate_field("lowerBound"));
6713 }
6714 lower_bound__ = map_.next_value()?;
6715 }
6716 GeneratedField::UpperBound => {
6717 if upper_bound__.is_some() {
6718 return Err(serde::de::Error::duplicate_field("upperBound"));
6719 }
6720 upper_bound__ = map_.next_value()?;
6721 }
6722 }
6723 }
6724 Ok(ScanRange {
6725 eq_conds: eq_conds__.unwrap_or_default(),
6726 lower_bound: lower_bound__,
6727 upper_bound: upper_bound__,
6728 })
6729 }
6730 }
6731 deserializer.deserialize_struct("batch_plan.ScanRange", FIELDS, GeneratedVisitor)
6732 }
6733}
6734impl serde::Serialize for scan_range::Bound {
6735 #[allow(deprecated)]
6736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6737 where
6738 S: serde::Serializer,
6739 {
6740 use serde::ser::SerializeStruct;
6741 let mut len = 0;
6742 if !self.value.is_empty() {
6743 len += 1;
6744 }
6745 if self.inclusive {
6746 len += 1;
6747 }
6748 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange.Bound", len)?;
6749 if !self.value.is_empty() {
6750 struct_ser.serialize_field("value", &self.value.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6751 }
6752 if self.inclusive {
6753 struct_ser.serialize_field("inclusive", &self.inclusive)?;
6754 }
6755 struct_ser.end()
6756 }
6757}
6758impl<'de> serde::Deserialize<'de> for scan_range::Bound {
6759 #[allow(deprecated)]
6760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6761 where
6762 D: serde::Deserializer<'de>,
6763 {
6764 const FIELDS: &[&str] = &[
6765 "value",
6766 "inclusive",
6767 ];
6768
6769 #[allow(clippy::enum_variant_names)]
6770 enum GeneratedField {
6771 Value,
6772 Inclusive,
6773 }
6774 impl<'de> serde::Deserialize<'de> for GeneratedField {
6775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6776 where
6777 D: serde::Deserializer<'de>,
6778 {
6779 struct GeneratedVisitor;
6780
6781 impl serde::de::Visitor<'_> for GeneratedVisitor {
6782 type Value = GeneratedField;
6783
6784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6785 write!(formatter, "expected one of: {:?}", &FIELDS)
6786 }
6787
6788 #[allow(unused_variables)]
6789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6790 where
6791 E: serde::de::Error,
6792 {
6793 match value {
6794 "value" => Ok(GeneratedField::Value),
6795 "inclusive" => Ok(GeneratedField::Inclusive),
6796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6797 }
6798 }
6799 }
6800 deserializer.deserialize_identifier(GeneratedVisitor)
6801 }
6802 }
6803 struct GeneratedVisitor;
6804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6805 type Value = scan_range::Bound;
6806
6807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6808 formatter.write_str("struct batch_plan.ScanRange.Bound")
6809 }
6810
6811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<scan_range::Bound, V::Error>
6812 where
6813 V: serde::de::MapAccess<'de>,
6814 {
6815 let mut value__ = None;
6816 let mut inclusive__ = None;
6817 while let Some(k) = map_.next_key()? {
6818 match k {
6819 GeneratedField::Value => {
6820 if value__.is_some() {
6821 return Err(serde::de::Error::duplicate_field("value"));
6822 }
6823 value__ =
6824 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6825 .into_iter().map(|x| x.0).collect())
6826 ;
6827 }
6828 GeneratedField::Inclusive => {
6829 if inclusive__.is_some() {
6830 return Err(serde::de::Error::duplicate_field("inclusive"));
6831 }
6832 inclusive__ = Some(map_.next_value()?);
6833 }
6834 }
6835 }
6836 Ok(scan_range::Bound {
6837 value: value__.unwrap_or_default(),
6838 inclusive: inclusive__.unwrap_or_default(),
6839 })
6840 }
6841 }
6842 deserializer.deserialize_struct("batch_plan.ScanRange.Bound", FIELDS, GeneratedVisitor)
6843 }
6844}
6845impl serde::Serialize for SortAggNode {
6846 #[allow(deprecated)]
6847 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6848 where
6849 S: serde::Serializer,
6850 {
6851 use serde::ser::SerializeStruct;
6852 let mut len = 0;
6853 if !self.group_key.is_empty() {
6854 len += 1;
6855 }
6856 if !self.agg_calls.is_empty() {
6857 len += 1;
6858 }
6859 let mut struct_ser = serializer.serialize_struct("batch_plan.SortAggNode", len)?;
6860 if !self.group_key.is_empty() {
6861 struct_ser.serialize_field("groupKey", &self.group_key)?;
6862 }
6863 if !self.agg_calls.is_empty() {
6864 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6865 }
6866 struct_ser.end()
6867 }
6868}
6869impl<'de> serde::Deserialize<'de> for SortAggNode {
6870 #[allow(deprecated)]
6871 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6872 where
6873 D: serde::Deserializer<'de>,
6874 {
6875 const FIELDS: &[&str] = &[
6876 "group_key",
6877 "groupKey",
6878 "agg_calls",
6879 "aggCalls",
6880 ];
6881
6882 #[allow(clippy::enum_variant_names)]
6883 enum GeneratedField {
6884 GroupKey,
6885 AggCalls,
6886 }
6887 impl<'de> serde::Deserialize<'de> for GeneratedField {
6888 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6889 where
6890 D: serde::Deserializer<'de>,
6891 {
6892 struct GeneratedVisitor;
6893
6894 impl serde::de::Visitor<'_> for GeneratedVisitor {
6895 type Value = GeneratedField;
6896
6897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6898 write!(formatter, "expected one of: {:?}", &FIELDS)
6899 }
6900
6901 #[allow(unused_variables)]
6902 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6903 where
6904 E: serde::de::Error,
6905 {
6906 match value {
6907 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6908 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6910 }
6911 }
6912 }
6913 deserializer.deserialize_identifier(GeneratedVisitor)
6914 }
6915 }
6916 struct GeneratedVisitor;
6917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6918 type Value = SortAggNode;
6919
6920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6921 formatter.write_str("struct batch_plan.SortAggNode")
6922 }
6923
6924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortAggNode, V::Error>
6925 where
6926 V: serde::de::MapAccess<'de>,
6927 {
6928 let mut group_key__ = None;
6929 let mut agg_calls__ = None;
6930 while let Some(k) = map_.next_key()? {
6931 match k {
6932 GeneratedField::GroupKey => {
6933 if group_key__.is_some() {
6934 return Err(serde::de::Error::duplicate_field("groupKey"));
6935 }
6936 group_key__ = Some(map_.next_value()?);
6937 }
6938 GeneratedField::AggCalls => {
6939 if agg_calls__.is_some() {
6940 return Err(serde::de::Error::duplicate_field("aggCalls"));
6941 }
6942 agg_calls__ = Some(map_.next_value()?);
6943 }
6944 }
6945 }
6946 Ok(SortAggNode {
6947 group_key: group_key__.unwrap_or_default(),
6948 agg_calls: agg_calls__.unwrap_or_default(),
6949 })
6950 }
6951 }
6952 deserializer.deserialize_struct("batch_plan.SortAggNode", FIELDS, GeneratedVisitor)
6953 }
6954}
6955impl serde::Serialize for SortMergeJoinNode {
6956 #[allow(deprecated)]
6957 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6958 where
6959 S: serde::Serializer,
6960 {
6961 use serde::ser::SerializeStruct;
6962 let mut len = 0;
6963 if self.join_type != 0 {
6964 len += 1;
6965 }
6966 if !self.left_key.is_empty() {
6967 len += 1;
6968 }
6969 if !self.right_key.is_empty() {
6970 len += 1;
6971 }
6972 if self.direction != 0 {
6973 len += 1;
6974 }
6975 if !self.output_indices.is_empty() {
6976 len += 1;
6977 }
6978 let mut struct_ser = serializer.serialize_struct("batch_plan.SortMergeJoinNode", len)?;
6979 if self.join_type != 0 {
6980 let v = super::plan_common::JoinType::try_from(self.join_type)
6981 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6982 struct_ser.serialize_field("joinType", &v)?;
6983 }
6984 if !self.left_key.is_empty() {
6985 struct_ser.serialize_field("leftKey", &self.left_key)?;
6986 }
6987 if !self.right_key.is_empty() {
6988 struct_ser.serialize_field("rightKey", &self.right_key)?;
6989 }
6990 if self.direction != 0 {
6991 let v = super::common::Direction::try_from(self.direction)
6992 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
6993 struct_ser.serialize_field("direction", &v)?;
6994 }
6995 if !self.output_indices.is_empty() {
6996 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6997 }
6998 struct_ser.end()
6999 }
7000}
7001impl<'de> serde::Deserialize<'de> for SortMergeJoinNode {
7002 #[allow(deprecated)]
7003 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7004 where
7005 D: serde::Deserializer<'de>,
7006 {
7007 const FIELDS: &[&str] = &[
7008 "join_type",
7009 "joinType",
7010 "left_key",
7011 "leftKey",
7012 "right_key",
7013 "rightKey",
7014 "direction",
7015 "output_indices",
7016 "outputIndices",
7017 ];
7018
7019 #[allow(clippy::enum_variant_names)]
7020 enum GeneratedField {
7021 JoinType,
7022 LeftKey,
7023 RightKey,
7024 Direction,
7025 OutputIndices,
7026 }
7027 impl<'de> serde::Deserialize<'de> for GeneratedField {
7028 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7029 where
7030 D: serde::Deserializer<'de>,
7031 {
7032 struct GeneratedVisitor;
7033
7034 impl serde::de::Visitor<'_> for GeneratedVisitor {
7035 type Value = GeneratedField;
7036
7037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7038 write!(formatter, "expected one of: {:?}", &FIELDS)
7039 }
7040
7041 #[allow(unused_variables)]
7042 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7043 where
7044 E: serde::de::Error,
7045 {
7046 match value {
7047 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
7048 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
7049 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
7050 "direction" => Ok(GeneratedField::Direction),
7051 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
7052 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7053 }
7054 }
7055 }
7056 deserializer.deserialize_identifier(GeneratedVisitor)
7057 }
7058 }
7059 struct GeneratedVisitor;
7060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7061 type Value = SortMergeJoinNode;
7062
7063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7064 formatter.write_str("struct batch_plan.SortMergeJoinNode")
7065 }
7066
7067 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortMergeJoinNode, V::Error>
7068 where
7069 V: serde::de::MapAccess<'de>,
7070 {
7071 let mut join_type__ = None;
7072 let mut left_key__ = None;
7073 let mut right_key__ = None;
7074 let mut direction__ = None;
7075 let mut output_indices__ = None;
7076 while let Some(k) = map_.next_key()? {
7077 match k {
7078 GeneratedField::JoinType => {
7079 if join_type__.is_some() {
7080 return Err(serde::de::Error::duplicate_field("joinType"));
7081 }
7082 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
7083 }
7084 GeneratedField::LeftKey => {
7085 if left_key__.is_some() {
7086 return Err(serde::de::Error::duplicate_field("leftKey"));
7087 }
7088 left_key__ =
7089 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7090 .into_iter().map(|x| x.0).collect())
7091 ;
7092 }
7093 GeneratedField::RightKey => {
7094 if right_key__.is_some() {
7095 return Err(serde::de::Error::duplicate_field("rightKey"));
7096 }
7097 right_key__ =
7098 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7099 .into_iter().map(|x| x.0).collect())
7100 ;
7101 }
7102 GeneratedField::Direction => {
7103 if direction__.is_some() {
7104 return Err(serde::de::Error::duplicate_field("direction"));
7105 }
7106 direction__ = Some(map_.next_value::<super::common::Direction>()? as i32);
7107 }
7108 GeneratedField::OutputIndices => {
7109 if output_indices__.is_some() {
7110 return Err(serde::de::Error::duplicate_field("outputIndices"));
7111 }
7112 output_indices__ =
7113 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7114 .into_iter().map(|x| x.0).collect())
7115 ;
7116 }
7117 }
7118 }
7119 Ok(SortMergeJoinNode {
7120 join_type: join_type__.unwrap_or_default(),
7121 left_key: left_key__.unwrap_or_default(),
7122 right_key: right_key__.unwrap_or_default(),
7123 direction: direction__.unwrap_or_default(),
7124 output_indices: output_indices__.unwrap_or_default(),
7125 })
7126 }
7127 }
7128 deserializer.deserialize_struct("batch_plan.SortMergeJoinNode", FIELDS, GeneratedVisitor)
7129 }
7130}
7131impl serde::Serialize for SortNode {
7132 #[allow(deprecated)]
7133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7134 where
7135 S: serde::Serializer,
7136 {
7137 use serde::ser::SerializeStruct;
7138 let mut len = 0;
7139 if !self.column_orders.is_empty() {
7140 len += 1;
7141 }
7142 let mut struct_ser = serializer.serialize_struct("batch_plan.SortNode", len)?;
7143 if !self.column_orders.is_empty() {
7144 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7145 }
7146 struct_ser.end()
7147 }
7148}
7149impl<'de> serde::Deserialize<'de> for SortNode {
7150 #[allow(deprecated)]
7151 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7152 where
7153 D: serde::Deserializer<'de>,
7154 {
7155 const FIELDS: &[&str] = &[
7156 "column_orders",
7157 "columnOrders",
7158 ];
7159
7160 #[allow(clippy::enum_variant_names)]
7161 enum GeneratedField {
7162 ColumnOrders,
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 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7185 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7186 }
7187 }
7188 }
7189 deserializer.deserialize_identifier(GeneratedVisitor)
7190 }
7191 }
7192 struct GeneratedVisitor;
7193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7194 type Value = SortNode;
7195
7196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7197 formatter.write_str("struct batch_plan.SortNode")
7198 }
7199
7200 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
7201 where
7202 V: serde::de::MapAccess<'de>,
7203 {
7204 let mut column_orders__ = None;
7205 while let Some(k) = map_.next_key()? {
7206 match k {
7207 GeneratedField::ColumnOrders => {
7208 if column_orders__.is_some() {
7209 return Err(serde::de::Error::duplicate_field("columnOrders"));
7210 }
7211 column_orders__ = Some(map_.next_value()?);
7212 }
7213 }
7214 }
7215 Ok(SortNode {
7216 column_orders: column_orders__.unwrap_or_default(),
7217 })
7218 }
7219 }
7220 deserializer.deserialize_struct("batch_plan.SortNode", FIELDS, GeneratedVisitor)
7221 }
7222}
7223impl serde::Serialize for SortOverWindowNode {
7224 #[allow(deprecated)]
7225 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7226 where
7227 S: serde::Serializer,
7228 {
7229 use serde::ser::SerializeStruct;
7230 let mut len = 0;
7231 if !self.calls.is_empty() {
7232 len += 1;
7233 }
7234 if !self.partition_by.is_empty() {
7235 len += 1;
7236 }
7237 if !self.order_by.is_empty() {
7238 len += 1;
7239 }
7240 let mut struct_ser = serializer.serialize_struct("batch_plan.SortOverWindowNode", len)?;
7241 if !self.calls.is_empty() {
7242 struct_ser.serialize_field("calls", &self.calls)?;
7243 }
7244 if !self.partition_by.is_empty() {
7245 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7246 }
7247 if !self.order_by.is_empty() {
7248 struct_ser.serialize_field("orderBy", &self.order_by)?;
7249 }
7250 struct_ser.end()
7251 }
7252}
7253impl<'de> serde::Deserialize<'de> for SortOverWindowNode {
7254 #[allow(deprecated)]
7255 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7256 where
7257 D: serde::Deserializer<'de>,
7258 {
7259 const FIELDS: &[&str] = &[
7260 "calls",
7261 "partition_by",
7262 "partitionBy",
7263 "order_by",
7264 "orderBy",
7265 ];
7266
7267 #[allow(clippy::enum_variant_names)]
7268 enum GeneratedField {
7269 Calls,
7270 PartitionBy,
7271 OrderBy,
7272 }
7273 impl<'de> serde::Deserialize<'de> for GeneratedField {
7274 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7275 where
7276 D: serde::Deserializer<'de>,
7277 {
7278 struct GeneratedVisitor;
7279
7280 impl serde::de::Visitor<'_> for GeneratedVisitor {
7281 type Value = GeneratedField;
7282
7283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7284 write!(formatter, "expected one of: {:?}", &FIELDS)
7285 }
7286
7287 #[allow(unused_variables)]
7288 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7289 where
7290 E: serde::de::Error,
7291 {
7292 match value {
7293 "calls" => Ok(GeneratedField::Calls),
7294 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7295 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7296 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7297 }
7298 }
7299 }
7300 deserializer.deserialize_identifier(GeneratedVisitor)
7301 }
7302 }
7303 struct GeneratedVisitor;
7304 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7305 type Value = SortOverWindowNode;
7306
7307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7308 formatter.write_str("struct batch_plan.SortOverWindowNode")
7309 }
7310
7311 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortOverWindowNode, V::Error>
7312 where
7313 V: serde::de::MapAccess<'de>,
7314 {
7315 let mut calls__ = None;
7316 let mut partition_by__ = None;
7317 let mut order_by__ = None;
7318 while let Some(k) = map_.next_key()? {
7319 match k {
7320 GeneratedField::Calls => {
7321 if calls__.is_some() {
7322 return Err(serde::de::Error::duplicate_field("calls"));
7323 }
7324 calls__ = Some(map_.next_value()?);
7325 }
7326 GeneratedField::PartitionBy => {
7327 if partition_by__.is_some() {
7328 return Err(serde::de::Error::duplicate_field("partitionBy"));
7329 }
7330 partition_by__ =
7331 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7332 .into_iter().map(|x| x.0).collect())
7333 ;
7334 }
7335 GeneratedField::OrderBy => {
7336 if order_by__.is_some() {
7337 return Err(serde::de::Error::duplicate_field("orderBy"));
7338 }
7339 order_by__ = Some(map_.next_value()?);
7340 }
7341 }
7342 }
7343 Ok(SortOverWindowNode {
7344 calls: calls__.unwrap_or_default(),
7345 partition_by: partition_by__.unwrap_or_default(),
7346 order_by: order_by__.unwrap_or_default(),
7347 })
7348 }
7349 }
7350 deserializer.deserialize_struct("batch_plan.SortOverWindowNode", FIELDS, GeneratedVisitor)
7351 }
7352}
7353impl serde::Serialize for SourceNode {
7354 #[allow(deprecated)]
7355 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7356 where
7357 S: serde::Serializer,
7358 {
7359 use serde::ser::SerializeStruct;
7360 let mut len = 0;
7361 if self.source_id != 0 {
7362 len += 1;
7363 }
7364 if !self.columns.is_empty() {
7365 len += 1;
7366 }
7367 if !self.with_properties.is_empty() {
7368 len += 1;
7369 }
7370 if !self.split.is_empty() {
7371 len += 1;
7372 }
7373 if self.info.is_some() {
7374 len += 1;
7375 }
7376 if !self.secret_refs.is_empty() {
7377 len += 1;
7378 }
7379 let mut struct_ser = serializer.serialize_struct("batch_plan.SourceNode", len)?;
7380 if self.source_id != 0 {
7381 struct_ser.serialize_field("sourceId", &self.source_id)?;
7382 }
7383 if !self.columns.is_empty() {
7384 struct_ser.serialize_field("columns", &self.columns)?;
7385 }
7386 if !self.with_properties.is_empty() {
7387 struct_ser.serialize_field("withProperties", &self.with_properties)?;
7388 }
7389 if !self.split.is_empty() {
7390 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
7391 }
7392 if let Some(v) = self.info.as_ref() {
7393 struct_ser.serialize_field("info", v)?;
7394 }
7395 if !self.secret_refs.is_empty() {
7396 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
7397 }
7398 struct_ser.end()
7399 }
7400}
7401impl<'de> serde::Deserialize<'de> for SourceNode {
7402 #[allow(deprecated)]
7403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7404 where
7405 D: serde::Deserializer<'de>,
7406 {
7407 const FIELDS: &[&str] = &[
7408 "source_id",
7409 "sourceId",
7410 "columns",
7411 "with_properties",
7412 "withProperties",
7413 "split",
7414 "info",
7415 "secret_refs",
7416 "secretRefs",
7417 ];
7418
7419 #[allow(clippy::enum_variant_names)]
7420 enum GeneratedField {
7421 SourceId,
7422 Columns,
7423 WithProperties,
7424 Split,
7425 Info,
7426 SecretRefs,
7427 }
7428 impl<'de> serde::Deserialize<'de> for GeneratedField {
7429 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7430 where
7431 D: serde::Deserializer<'de>,
7432 {
7433 struct GeneratedVisitor;
7434
7435 impl serde::de::Visitor<'_> for GeneratedVisitor {
7436 type Value = GeneratedField;
7437
7438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7439 write!(formatter, "expected one of: {:?}", &FIELDS)
7440 }
7441
7442 #[allow(unused_variables)]
7443 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7444 where
7445 E: serde::de::Error,
7446 {
7447 match value {
7448 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7449 "columns" => Ok(GeneratedField::Columns),
7450 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
7451 "split" => Ok(GeneratedField::Split),
7452 "info" => Ok(GeneratedField::Info),
7453 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
7454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7455 }
7456 }
7457 }
7458 deserializer.deserialize_identifier(GeneratedVisitor)
7459 }
7460 }
7461 struct GeneratedVisitor;
7462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7463 type Value = SourceNode;
7464
7465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7466 formatter.write_str("struct batch_plan.SourceNode")
7467 }
7468
7469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
7470 where
7471 V: serde::de::MapAccess<'de>,
7472 {
7473 let mut source_id__ = None;
7474 let mut columns__ = None;
7475 let mut with_properties__ = None;
7476 let mut split__ = None;
7477 let mut info__ = None;
7478 let mut secret_refs__ = None;
7479 while let Some(k) = map_.next_key()? {
7480 match k {
7481 GeneratedField::SourceId => {
7482 if source_id__.is_some() {
7483 return Err(serde::de::Error::duplicate_field("sourceId"));
7484 }
7485 source_id__ =
7486 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7487 ;
7488 }
7489 GeneratedField::Columns => {
7490 if columns__.is_some() {
7491 return Err(serde::de::Error::duplicate_field("columns"));
7492 }
7493 columns__ = Some(map_.next_value()?);
7494 }
7495 GeneratedField::WithProperties => {
7496 if with_properties__.is_some() {
7497 return Err(serde::de::Error::duplicate_field("withProperties"));
7498 }
7499 with_properties__ = Some(
7500 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7501 );
7502 }
7503 GeneratedField::Split => {
7504 if split__.is_some() {
7505 return Err(serde::de::Error::duplicate_field("split"));
7506 }
7507 split__ =
7508 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7509 .into_iter().map(|x| x.0).collect())
7510 ;
7511 }
7512 GeneratedField::Info => {
7513 if info__.is_some() {
7514 return Err(serde::de::Error::duplicate_field("info"));
7515 }
7516 info__ = map_.next_value()?;
7517 }
7518 GeneratedField::SecretRefs => {
7519 if secret_refs__.is_some() {
7520 return Err(serde::de::Error::duplicate_field("secretRefs"));
7521 }
7522 secret_refs__ = Some(
7523 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7524 );
7525 }
7526 }
7527 }
7528 Ok(SourceNode {
7529 source_id: source_id__.unwrap_or_default(),
7530 columns: columns__.unwrap_or_default(),
7531 with_properties: with_properties__.unwrap_or_default(),
7532 split: split__.unwrap_or_default(),
7533 info: info__,
7534 secret_refs: secret_refs__.unwrap_or_default(),
7535 })
7536 }
7537 }
7538 deserializer.deserialize_struct("batch_plan.SourceNode", FIELDS, GeneratedVisitor)
7539 }
7540}
7541impl serde::Serialize for SysRowSeqScanNode {
7542 #[allow(deprecated)]
7543 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7544 where
7545 S: serde::Serializer,
7546 {
7547 use serde::ser::SerializeStruct;
7548 let mut len = 0;
7549 if self.table_id != 0 {
7550 len += 1;
7551 }
7552 if !self.column_descs.is_empty() {
7553 len += 1;
7554 }
7555 let mut struct_ser = serializer.serialize_struct("batch_plan.SysRowSeqScanNode", len)?;
7556 if self.table_id != 0 {
7557 struct_ser.serialize_field("tableId", &self.table_id)?;
7558 }
7559 if !self.column_descs.is_empty() {
7560 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
7561 }
7562 struct_ser.end()
7563 }
7564}
7565impl<'de> serde::Deserialize<'de> for SysRowSeqScanNode {
7566 #[allow(deprecated)]
7567 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7568 where
7569 D: serde::Deserializer<'de>,
7570 {
7571 const FIELDS: &[&str] = &[
7572 "table_id",
7573 "tableId",
7574 "column_descs",
7575 "columnDescs",
7576 ];
7577
7578 #[allow(clippy::enum_variant_names)]
7579 enum GeneratedField {
7580 TableId,
7581 ColumnDescs,
7582 }
7583 impl<'de> serde::Deserialize<'de> for GeneratedField {
7584 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7585 where
7586 D: serde::Deserializer<'de>,
7587 {
7588 struct GeneratedVisitor;
7589
7590 impl serde::de::Visitor<'_> for GeneratedVisitor {
7591 type Value = GeneratedField;
7592
7593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7594 write!(formatter, "expected one of: {:?}", &FIELDS)
7595 }
7596
7597 #[allow(unused_variables)]
7598 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7599 where
7600 E: serde::de::Error,
7601 {
7602 match value {
7603 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7604 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
7605 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7606 }
7607 }
7608 }
7609 deserializer.deserialize_identifier(GeneratedVisitor)
7610 }
7611 }
7612 struct GeneratedVisitor;
7613 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7614 type Value = SysRowSeqScanNode;
7615
7616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7617 formatter.write_str("struct batch_plan.SysRowSeqScanNode")
7618 }
7619
7620 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SysRowSeqScanNode, V::Error>
7621 where
7622 V: serde::de::MapAccess<'de>,
7623 {
7624 let mut table_id__ = None;
7625 let mut column_descs__ = None;
7626 while let Some(k) = map_.next_key()? {
7627 match k {
7628 GeneratedField::TableId => {
7629 if table_id__.is_some() {
7630 return Err(serde::de::Error::duplicate_field("tableId"));
7631 }
7632 table_id__ =
7633 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7634 ;
7635 }
7636 GeneratedField::ColumnDescs => {
7637 if column_descs__.is_some() {
7638 return Err(serde::de::Error::duplicate_field("columnDescs"));
7639 }
7640 column_descs__ = Some(map_.next_value()?);
7641 }
7642 }
7643 }
7644 Ok(SysRowSeqScanNode {
7645 table_id: table_id__.unwrap_or_default(),
7646 column_descs: column_descs__.unwrap_or_default(),
7647 })
7648 }
7649 }
7650 deserializer.deserialize_struct("batch_plan.SysRowSeqScanNode", FIELDS, GeneratedVisitor)
7651 }
7652}
7653impl serde::Serialize for TableFunctionNode {
7654 #[allow(deprecated)]
7655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7656 where
7657 S: serde::Serializer,
7658 {
7659 use serde::ser::SerializeStruct;
7660 let mut len = 0;
7661 if self.table_function.is_some() {
7662 len += 1;
7663 }
7664 let mut struct_ser = serializer.serialize_struct("batch_plan.TableFunctionNode", len)?;
7665 if let Some(v) = self.table_function.as_ref() {
7666 struct_ser.serialize_field("tableFunction", v)?;
7667 }
7668 struct_ser.end()
7669 }
7670}
7671impl<'de> serde::Deserialize<'de> for TableFunctionNode {
7672 #[allow(deprecated)]
7673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7674 where
7675 D: serde::Deserializer<'de>,
7676 {
7677 const FIELDS: &[&str] = &[
7678 "table_function",
7679 "tableFunction",
7680 ];
7681
7682 #[allow(clippy::enum_variant_names)]
7683 enum GeneratedField {
7684 TableFunction,
7685 }
7686 impl<'de> serde::Deserialize<'de> for GeneratedField {
7687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7688 where
7689 D: serde::Deserializer<'de>,
7690 {
7691 struct GeneratedVisitor;
7692
7693 impl serde::de::Visitor<'_> for GeneratedVisitor {
7694 type Value = GeneratedField;
7695
7696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7697 write!(formatter, "expected one of: {:?}", &FIELDS)
7698 }
7699
7700 #[allow(unused_variables)]
7701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7702 where
7703 E: serde::de::Error,
7704 {
7705 match value {
7706 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
7707 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7708 }
7709 }
7710 }
7711 deserializer.deserialize_identifier(GeneratedVisitor)
7712 }
7713 }
7714 struct GeneratedVisitor;
7715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7716 type Value = TableFunctionNode;
7717
7718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7719 formatter.write_str("struct batch_plan.TableFunctionNode")
7720 }
7721
7722 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunctionNode, V::Error>
7723 where
7724 V: serde::de::MapAccess<'de>,
7725 {
7726 let mut table_function__ = None;
7727 while let Some(k) = map_.next_key()? {
7728 match k {
7729 GeneratedField::TableFunction => {
7730 if table_function__.is_some() {
7731 return Err(serde::de::Error::duplicate_field("tableFunction"));
7732 }
7733 table_function__ = map_.next_value()?;
7734 }
7735 }
7736 }
7737 Ok(TableFunctionNode {
7738 table_function: table_function__,
7739 })
7740 }
7741 }
7742 deserializer.deserialize_struct("batch_plan.TableFunctionNode", FIELDS, GeneratedVisitor)
7743 }
7744}
7745impl serde::Serialize for TaskId {
7746 #[allow(deprecated)]
7747 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7748 where
7749 S: serde::Serializer,
7750 {
7751 use serde::ser::SerializeStruct;
7752 let mut len = 0;
7753 if !self.query_id.is_empty() {
7754 len += 1;
7755 }
7756 if self.stage_id != 0 {
7757 len += 1;
7758 }
7759 if self.task_id != 0 {
7760 len += 1;
7761 }
7762 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskId", len)?;
7763 if !self.query_id.is_empty() {
7764 struct_ser.serialize_field("queryId", &self.query_id)?;
7765 }
7766 if self.stage_id != 0 {
7767 struct_ser.serialize_field("stageId", &self.stage_id)?;
7768 }
7769 if self.task_id != 0 {
7770 #[allow(clippy::needless_borrow)]
7771 #[allow(clippy::needless_borrows_for_generic_args)]
7772 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7773 }
7774 struct_ser.end()
7775 }
7776}
7777impl<'de> serde::Deserialize<'de> for TaskId {
7778 #[allow(deprecated)]
7779 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7780 where
7781 D: serde::Deserializer<'de>,
7782 {
7783 const FIELDS: &[&str] = &[
7784 "query_id",
7785 "queryId",
7786 "stage_id",
7787 "stageId",
7788 "task_id",
7789 "taskId",
7790 ];
7791
7792 #[allow(clippy::enum_variant_names)]
7793 enum GeneratedField {
7794 QueryId,
7795 StageId,
7796 TaskId,
7797 }
7798 impl<'de> serde::Deserialize<'de> for GeneratedField {
7799 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7800 where
7801 D: serde::Deserializer<'de>,
7802 {
7803 struct GeneratedVisitor;
7804
7805 impl serde::de::Visitor<'_> for GeneratedVisitor {
7806 type Value = GeneratedField;
7807
7808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7809 write!(formatter, "expected one of: {:?}", &FIELDS)
7810 }
7811
7812 #[allow(unused_variables)]
7813 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7814 where
7815 E: serde::de::Error,
7816 {
7817 match value {
7818 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
7819 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
7820 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7821 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7822 }
7823 }
7824 }
7825 deserializer.deserialize_identifier(GeneratedVisitor)
7826 }
7827 }
7828 struct GeneratedVisitor;
7829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7830 type Value = TaskId;
7831
7832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7833 formatter.write_str("struct batch_plan.TaskId")
7834 }
7835
7836 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
7837 where
7838 V: serde::de::MapAccess<'de>,
7839 {
7840 let mut query_id__ = None;
7841 let mut stage_id__ = None;
7842 let mut task_id__ = None;
7843 while let Some(k) = map_.next_key()? {
7844 match k {
7845 GeneratedField::QueryId => {
7846 if query_id__.is_some() {
7847 return Err(serde::de::Error::duplicate_field("queryId"));
7848 }
7849 query_id__ = Some(map_.next_value()?);
7850 }
7851 GeneratedField::StageId => {
7852 if stage_id__.is_some() {
7853 return Err(serde::de::Error::duplicate_field("stageId"));
7854 }
7855 stage_id__ =
7856 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7857 ;
7858 }
7859 GeneratedField::TaskId => {
7860 if task_id__.is_some() {
7861 return Err(serde::de::Error::duplicate_field("taskId"));
7862 }
7863 task_id__ =
7864 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7865 ;
7866 }
7867 }
7868 }
7869 Ok(TaskId {
7870 query_id: query_id__.unwrap_or_default(),
7871 stage_id: stage_id__.unwrap_or_default(),
7872 task_id: task_id__.unwrap_or_default(),
7873 })
7874 }
7875 }
7876 deserializer.deserialize_struct("batch_plan.TaskId", FIELDS, GeneratedVisitor)
7877 }
7878}
7879impl serde::Serialize for TaskOutputId {
7880 #[allow(deprecated)]
7881 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7882 where
7883 S: serde::Serializer,
7884 {
7885 use serde::ser::SerializeStruct;
7886 let mut len = 0;
7887 if self.task_id.is_some() {
7888 len += 1;
7889 }
7890 if self.output_id != 0 {
7891 len += 1;
7892 }
7893 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskOutputId", len)?;
7894 if let Some(v) = self.task_id.as_ref() {
7895 struct_ser.serialize_field("taskId", v)?;
7896 }
7897 if self.output_id != 0 {
7898 #[allow(clippy::needless_borrow)]
7899 #[allow(clippy::needless_borrows_for_generic_args)]
7900 struct_ser.serialize_field("outputId", ToString::to_string(&self.output_id).as_str())?;
7901 }
7902 struct_ser.end()
7903 }
7904}
7905impl<'de> serde::Deserialize<'de> for TaskOutputId {
7906 #[allow(deprecated)]
7907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7908 where
7909 D: serde::Deserializer<'de>,
7910 {
7911 const FIELDS: &[&str] = &[
7912 "task_id",
7913 "taskId",
7914 "output_id",
7915 "outputId",
7916 ];
7917
7918 #[allow(clippy::enum_variant_names)]
7919 enum GeneratedField {
7920 TaskId,
7921 OutputId,
7922 }
7923 impl<'de> serde::Deserialize<'de> for GeneratedField {
7924 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7925 where
7926 D: serde::Deserializer<'de>,
7927 {
7928 struct GeneratedVisitor;
7929
7930 impl serde::de::Visitor<'_> for GeneratedVisitor {
7931 type Value = GeneratedField;
7932
7933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7934 write!(formatter, "expected one of: {:?}", &FIELDS)
7935 }
7936
7937 #[allow(unused_variables)]
7938 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7939 where
7940 E: serde::de::Error,
7941 {
7942 match value {
7943 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7944 "outputId" | "output_id" => Ok(GeneratedField::OutputId),
7945 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7946 }
7947 }
7948 }
7949 deserializer.deserialize_identifier(GeneratedVisitor)
7950 }
7951 }
7952 struct GeneratedVisitor;
7953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7954 type Value = TaskOutputId;
7955
7956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7957 formatter.write_str("struct batch_plan.TaskOutputId")
7958 }
7959
7960 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskOutputId, V::Error>
7961 where
7962 V: serde::de::MapAccess<'de>,
7963 {
7964 let mut task_id__ = None;
7965 let mut output_id__ = None;
7966 while let Some(k) = map_.next_key()? {
7967 match k {
7968 GeneratedField::TaskId => {
7969 if task_id__.is_some() {
7970 return Err(serde::de::Error::duplicate_field("taskId"));
7971 }
7972 task_id__ = map_.next_value()?;
7973 }
7974 GeneratedField::OutputId => {
7975 if output_id__.is_some() {
7976 return Err(serde::de::Error::duplicate_field("outputId"));
7977 }
7978 output_id__ =
7979 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7980 ;
7981 }
7982 }
7983 }
7984 Ok(TaskOutputId {
7985 task_id: task_id__,
7986 output_id: output_id__.unwrap_or_default(),
7987 })
7988 }
7989 }
7990 deserializer.deserialize_struct("batch_plan.TaskOutputId", FIELDS, GeneratedVisitor)
7991 }
7992}
7993impl serde::Serialize for TopNNode {
7994 #[allow(deprecated)]
7995 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7996 where
7997 S: serde::Serializer,
7998 {
7999 use serde::ser::SerializeStruct;
8000 let mut len = 0;
8001 if !self.column_orders.is_empty() {
8002 len += 1;
8003 }
8004 if self.limit != 0 {
8005 len += 1;
8006 }
8007 if self.offset != 0 {
8008 len += 1;
8009 }
8010 if self.with_ties {
8011 len += 1;
8012 }
8013 let mut struct_ser = serializer.serialize_struct("batch_plan.TopNNode", len)?;
8014 if !self.column_orders.is_empty() {
8015 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
8016 }
8017 if self.limit != 0 {
8018 #[allow(clippy::needless_borrow)]
8019 #[allow(clippy::needless_borrows_for_generic_args)]
8020 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
8021 }
8022 if self.offset != 0 {
8023 #[allow(clippy::needless_borrow)]
8024 #[allow(clippy::needless_borrows_for_generic_args)]
8025 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
8026 }
8027 if self.with_ties {
8028 struct_ser.serialize_field("withTies", &self.with_ties)?;
8029 }
8030 struct_ser.end()
8031 }
8032}
8033impl<'de> serde::Deserialize<'de> for TopNNode {
8034 #[allow(deprecated)]
8035 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8036 where
8037 D: serde::Deserializer<'de>,
8038 {
8039 const FIELDS: &[&str] = &[
8040 "column_orders",
8041 "columnOrders",
8042 "limit",
8043 "offset",
8044 "with_ties",
8045 "withTies",
8046 ];
8047
8048 #[allow(clippy::enum_variant_names)]
8049 enum GeneratedField {
8050 ColumnOrders,
8051 Limit,
8052 Offset,
8053 WithTies,
8054 }
8055 impl<'de> serde::Deserialize<'de> for GeneratedField {
8056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8057 where
8058 D: serde::Deserializer<'de>,
8059 {
8060 struct GeneratedVisitor;
8061
8062 impl serde::de::Visitor<'_> for GeneratedVisitor {
8063 type Value = GeneratedField;
8064
8065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8066 write!(formatter, "expected one of: {:?}", &FIELDS)
8067 }
8068
8069 #[allow(unused_variables)]
8070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8071 where
8072 E: serde::de::Error,
8073 {
8074 match value {
8075 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
8076 "limit" => Ok(GeneratedField::Limit),
8077 "offset" => Ok(GeneratedField::Offset),
8078 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
8079 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8080 }
8081 }
8082 }
8083 deserializer.deserialize_identifier(GeneratedVisitor)
8084 }
8085 }
8086 struct GeneratedVisitor;
8087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8088 type Value = TopNNode;
8089
8090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8091 formatter.write_str("struct batch_plan.TopNNode")
8092 }
8093
8094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
8095 where
8096 V: serde::de::MapAccess<'de>,
8097 {
8098 let mut column_orders__ = None;
8099 let mut limit__ = None;
8100 let mut offset__ = None;
8101 let mut with_ties__ = None;
8102 while let Some(k) = map_.next_key()? {
8103 match k {
8104 GeneratedField::ColumnOrders => {
8105 if column_orders__.is_some() {
8106 return Err(serde::de::Error::duplicate_field("columnOrders"));
8107 }
8108 column_orders__ = Some(map_.next_value()?);
8109 }
8110 GeneratedField::Limit => {
8111 if limit__.is_some() {
8112 return Err(serde::de::Error::duplicate_field("limit"));
8113 }
8114 limit__ =
8115 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8116 ;
8117 }
8118 GeneratedField::Offset => {
8119 if offset__.is_some() {
8120 return Err(serde::de::Error::duplicate_field("offset"));
8121 }
8122 offset__ =
8123 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8124 ;
8125 }
8126 GeneratedField::WithTies => {
8127 if with_ties__.is_some() {
8128 return Err(serde::de::Error::duplicate_field("withTies"));
8129 }
8130 with_ties__ = Some(map_.next_value()?);
8131 }
8132 }
8133 }
8134 Ok(TopNNode {
8135 column_orders: column_orders__.unwrap_or_default(),
8136 limit: limit__.unwrap_or_default(),
8137 offset: offset__.unwrap_or_default(),
8138 with_ties: with_ties__.unwrap_or_default(),
8139 })
8140 }
8141 }
8142 deserializer.deserialize_struct("batch_plan.TopNNode", FIELDS, GeneratedVisitor)
8143 }
8144}
8145impl serde::Serialize for UnionNode {
8146 #[allow(deprecated)]
8147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8148 where
8149 S: serde::Serializer,
8150 {
8151 use serde::ser::SerializeStruct;
8152 let len = 0;
8153 let struct_ser = serializer.serialize_struct("batch_plan.UnionNode", len)?;
8154 struct_ser.end()
8155 }
8156}
8157impl<'de> serde::Deserialize<'de> for UnionNode {
8158 #[allow(deprecated)]
8159 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8160 where
8161 D: serde::Deserializer<'de>,
8162 {
8163 const FIELDS: &[&str] = &[
8164 ];
8165
8166 #[allow(clippy::enum_variant_names)]
8167 enum GeneratedField {
8168 }
8169 impl<'de> serde::Deserialize<'de> for GeneratedField {
8170 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8171 where
8172 D: serde::Deserializer<'de>,
8173 {
8174 struct GeneratedVisitor;
8175
8176 impl serde::de::Visitor<'_> for GeneratedVisitor {
8177 type Value = GeneratedField;
8178
8179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8180 write!(formatter, "expected one of: {:?}", &FIELDS)
8181 }
8182
8183 #[allow(unused_variables)]
8184 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8185 where
8186 E: serde::de::Error,
8187 {
8188 Err(serde::de::Error::unknown_field(value, FIELDS))
8189 }
8190 }
8191 deserializer.deserialize_identifier(GeneratedVisitor)
8192 }
8193 }
8194 struct GeneratedVisitor;
8195 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8196 type Value = UnionNode;
8197
8198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8199 formatter.write_str("struct batch_plan.UnionNode")
8200 }
8201
8202 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
8203 where
8204 V: serde::de::MapAccess<'de>,
8205 {
8206 while map_.next_key::<GeneratedField>()?.is_some() {
8207 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8208 }
8209 Ok(UnionNode {
8210 })
8211 }
8212 }
8213 deserializer.deserialize_struct("batch_plan.UnionNode", FIELDS, GeneratedVisitor)
8214 }
8215}
8216impl serde::Serialize for UpdateNode {
8217 #[allow(deprecated)]
8218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8219 where
8220 S: serde::Serializer,
8221 {
8222 use serde::ser::SerializeStruct;
8223 let mut len = 0;
8224 if self.table_id != 0 {
8225 len += 1;
8226 }
8227 if self.table_version_id != 0 {
8228 len += 1;
8229 }
8230 if !self.old_exprs.is_empty() {
8231 len += 1;
8232 }
8233 if !self.new_exprs.is_empty() {
8234 len += 1;
8235 }
8236 if self.returning {
8237 len += 1;
8238 }
8239 if self.upsert {
8240 len += 1;
8241 }
8242 if self.session_id != 0 {
8243 len += 1;
8244 }
8245 if self.wait_for_persistence {
8246 len += 1;
8247 }
8248 let mut struct_ser = serializer.serialize_struct("batch_plan.UpdateNode", len)?;
8249 if self.table_id != 0 {
8250 struct_ser.serialize_field("tableId", &self.table_id)?;
8251 }
8252 if self.table_version_id != 0 {
8253 #[allow(clippy::needless_borrow)]
8254 #[allow(clippy::needless_borrows_for_generic_args)]
8255 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
8256 }
8257 if !self.old_exprs.is_empty() {
8258 struct_ser.serialize_field("oldExprs", &self.old_exprs)?;
8259 }
8260 if !self.new_exprs.is_empty() {
8261 struct_ser.serialize_field("newExprs", &self.new_exprs)?;
8262 }
8263 if self.returning {
8264 struct_ser.serialize_field("returning", &self.returning)?;
8265 }
8266 if self.upsert {
8267 struct_ser.serialize_field("upsert", &self.upsert)?;
8268 }
8269 if self.session_id != 0 {
8270 struct_ser.serialize_field("sessionId", &self.session_id)?;
8271 }
8272 if self.wait_for_persistence {
8273 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
8274 }
8275 struct_ser.end()
8276 }
8277}
8278impl<'de> serde::Deserialize<'de> for UpdateNode {
8279 #[allow(deprecated)]
8280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8281 where
8282 D: serde::Deserializer<'de>,
8283 {
8284 const FIELDS: &[&str] = &[
8285 "table_id",
8286 "tableId",
8287 "table_version_id",
8288 "tableVersionId",
8289 "old_exprs",
8290 "oldExprs",
8291 "new_exprs",
8292 "newExprs",
8293 "returning",
8294 "upsert",
8295 "session_id",
8296 "sessionId",
8297 "wait_for_persistence",
8298 "waitForPersistence",
8299 ];
8300
8301 #[allow(clippy::enum_variant_names)]
8302 enum GeneratedField {
8303 TableId,
8304 TableVersionId,
8305 OldExprs,
8306 NewExprs,
8307 Returning,
8308 Upsert,
8309 SessionId,
8310 WaitForPersistence,
8311 }
8312 impl<'de> serde::Deserialize<'de> for GeneratedField {
8313 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8314 where
8315 D: serde::Deserializer<'de>,
8316 {
8317 struct GeneratedVisitor;
8318
8319 impl serde::de::Visitor<'_> for GeneratedVisitor {
8320 type Value = GeneratedField;
8321
8322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8323 write!(formatter, "expected one of: {:?}", &FIELDS)
8324 }
8325
8326 #[allow(unused_variables)]
8327 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8328 where
8329 E: serde::de::Error,
8330 {
8331 match value {
8332 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8333 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
8334 "oldExprs" | "old_exprs" => Ok(GeneratedField::OldExprs),
8335 "newExprs" | "new_exprs" => Ok(GeneratedField::NewExprs),
8336 "returning" => Ok(GeneratedField::Returning),
8337 "upsert" => Ok(GeneratedField::Upsert),
8338 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
8339 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
8340 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8341 }
8342 }
8343 }
8344 deserializer.deserialize_identifier(GeneratedVisitor)
8345 }
8346 }
8347 struct GeneratedVisitor;
8348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8349 type Value = UpdateNode;
8350
8351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8352 formatter.write_str("struct batch_plan.UpdateNode")
8353 }
8354
8355 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateNode, V::Error>
8356 where
8357 V: serde::de::MapAccess<'de>,
8358 {
8359 let mut table_id__ = None;
8360 let mut table_version_id__ = None;
8361 let mut old_exprs__ = None;
8362 let mut new_exprs__ = None;
8363 let mut returning__ = None;
8364 let mut upsert__ = None;
8365 let mut session_id__ = None;
8366 let mut wait_for_persistence__ = None;
8367 while let Some(k) = map_.next_key()? {
8368 match k {
8369 GeneratedField::TableId => {
8370 if table_id__.is_some() {
8371 return Err(serde::de::Error::duplicate_field("tableId"));
8372 }
8373 table_id__ =
8374 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8375 ;
8376 }
8377 GeneratedField::TableVersionId => {
8378 if table_version_id__.is_some() {
8379 return Err(serde::de::Error::duplicate_field("tableVersionId"));
8380 }
8381 table_version_id__ =
8382 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8383 ;
8384 }
8385 GeneratedField::OldExprs => {
8386 if old_exprs__.is_some() {
8387 return Err(serde::de::Error::duplicate_field("oldExprs"));
8388 }
8389 old_exprs__ = Some(map_.next_value()?);
8390 }
8391 GeneratedField::NewExprs => {
8392 if new_exprs__.is_some() {
8393 return Err(serde::de::Error::duplicate_field("newExprs"));
8394 }
8395 new_exprs__ = Some(map_.next_value()?);
8396 }
8397 GeneratedField::Returning => {
8398 if returning__.is_some() {
8399 return Err(serde::de::Error::duplicate_field("returning"));
8400 }
8401 returning__ = Some(map_.next_value()?);
8402 }
8403 GeneratedField::Upsert => {
8404 if upsert__.is_some() {
8405 return Err(serde::de::Error::duplicate_field("upsert"));
8406 }
8407 upsert__ = Some(map_.next_value()?);
8408 }
8409 GeneratedField::SessionId => {
8410 if session_id__.is_some() {
8411 return Err(serde::de::Error::duplicate_field("sessionId"));
8412 }
8413 session_id__ =
8414 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8415 ;
8416 }
8417 GeneratedField::WaitForPersistence => {
8418 if wait_for_persistence__.is_some() {
8419 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
8420 }
8421 wait_for_persistence__ = Some(map_.next_value()?);
8422 }
8423 }
8424 }
8425 Ok(UpdateNode {
8426 table_id: table_id__.unwrap_or_default(),
8427 table_version_id: table_version_id__.unwrap_or_default(),
8428 old_exprs: old_exprs__.unwrap_or_default(),
8429 new_exprs: new_exprs__.unwrap_or_default(),
8430 returning: returning__.unwrap_or_default(),
8431 upsert: upsert__.unwrap_or_default(),
8432 session_id: session_id__.unwrap_or_default(),
8433 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
8434 })
8435 }
8436 }
8437 deserializer.deserialize_struct("batch_plan.UpdateNode", FIELDS, GeneratedVisitor)
8438 }
8439}
8440impl serde::Serialize for ValuesNode {
8441 #[allow(deprecated)]
8442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8443 where
8444 S: serde::Serializer,
8445 {
8446 use serde::ser::SerializeStruct;
8447 let mut len = 0;
8448 if !self.tuples.is_empty() {
8449 len += 1;
8450 }
8451 if !self.fields.is_empty() {
8452 len += 1;
8453 }
8454 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode", len)?;
8455 if !self.tuples.is_empty() {
8456 struct_ser.serialize_field("tuples", &self.tuples)?;
8457 }
8458 if !self.fields.is_empty() {
8459 struct_ser.serialize_field("fields", &self.fields)?;
8460 }
8461 struct_ser.end()
8462 }
8463}
8464impl<'de> serde::Deserialize<'de> for ValuesNode {
8465 #[allow(deprecated)]
8466 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8467 where
8468 D: serde::Deserializer<'de>,
8469 {
8470 const FIELDS: &[&str] = &[
8471 "tuples",
8472 "fields",
8473 ];
8474
8475 #[allow(clippy::enum_variant_names)]
8476 enum GeneratedField {
8477 Tuples,
8478 Fields,
8479 }
8480 impl<'de> serde::Deserialize<'de> for GeneratedField {
8481 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8482 where
8483 D: serde::Deserializer<'de>,
8484 {
8485 struct GeneratedVisitor;
8486
8487 impl serde::de::Visitor<'_> for GeneratedVisitor {
8488 type Value = GeneratedField;
8489
8490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8491 write!(formatter, "expected one of: {:?}", &FIELDS)
8492 }
8493
8494 #[allow(unused_variables)]
8495 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8496 where
8497 E: serde::de::Error,
8498 {
8499 match value {
8500 "tuples" => Ok(GeneratedField::Tuples),
8501 "fields" => Ok(GeneratedField::Fields),
8502 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8503 }
8504 }
8505 }
8506 deserializer.deserialize_identifier(GeneratedVisitor)
8507 }
8508 }
8509 struct GeneratedVisitor;
8510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8511 type Value = ValuesNode;
8512
8513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8514 formatter.write_str("struct batch_plan.ValuesNode")
8515 }
8516
8517 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
8518 where
8519 V: serde::de::MapAccess<'de>,
8520 {
8521 let mut tuples__ = None;
8522 let mut fields__ = None;
8523 while let Some(k) = map_.next_key()? {
8524 match k {
8525 GeneratedField::Tuples => {
8526 if tuples__.is_some() {
8527 return Err(serde::de::Error::duplicate_field("tuples"));
8528 }
8529 tuples__ = Some(map_.next_value()?);
8530 }
8531 GeneratedField::Fields => {
8532 if fields__.is_some() {
8533 return Err(serde::de::Error::duplicate_field("fields"));
8534 }
8535 fields__ = Some(map_.next_value()?);
8536 }
8537 }
8538 }
8539 Ok(ValuesNode {
8540 tuples: tuples__.unwrap_or_default(),
8541 fields: fields__.unwrap_or_default(),
8542 })
8543 }
8544 }
8545 deserializer.deserialize_struct("batch_plan.ValuesNode", FIELDS, GeneratedVisitor)
8546 }
8547}
8548impl serde::Serialize for values_node::ExprTuple {
8549 #[allow(deprecated)]
8550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8551 where
8552 S: serde::Serializer,
8553 {
8554 use serde::ser::SerializeStruct;
8555 let mut len = 0;
8556 if !self.cells.is_empty() {
8557 len += 1;
8558 }
8559 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode.ExprTuple", len)?;
8560 if !self.cells.is_empty() {
8561 struct_ser.serialize_field("cells", &self.cells)?;
8562 }
8563 struct_ser.end()
8564 }
8565}
8566impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
8567 #[allow(deprecated)]
8568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8569 where
8570 D: serde::Deserializer<'de>,
8571 {
8572 const FIELDS: &[&str] = &[
8573 "cells",
8574 ];
8575
8576 #[allow(clippy::enum_variant_names)]
8577 enum GeneratedField {
8578 Cells,
8579 }
8580 impl<'de> serde::Deserialize<'de> for GeneratedField {
8581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8582 where
8583 D: serde::Deserializer<'de>,
8584 {
8585 struct GeneratedVisitor;
8586
8587 impl serde::de::Visitor<'_> for GeneratedVisitor {
8588 type Value = GeneratedField;
8589
8590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8591 write!(formatter, "expected one of: {:?}", &FIELDS)
8592 }
8593
8594 #[allow(unused_variables)]
8595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8596 where
8597 E: serde::de::Error,
8598 {
8599 match value {
8600 "cells" => Ok(GeneratedField::Cells),
8601 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8602 }
8603 }
8604 }
8605 deserializer.deserialize_identifier(GeneratedVisitor)
8606 }
8607 }
8608 struct GeneratedVisitor;
8609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8610 type Value = values_node::ExprTuple;
8611
8612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8613 formatter.write_str("struct batch_plan.ValuesNode.ExprTuple")
8614 }
8615
8616 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
8617 where
8618 V: serde::de::MapAccess<'de>,
8619 {
8620 let mut cells__ = None;
8621 while let Some(k) = map_.next_key()? {
8622 match k {
8623 GeneratedField::Cells => {
8624 if cells__.is_some() {
8625 return Err(serde::de::Error::duplicate_field("cells"));
8626 }
8627 cells__ = Some(map_.next_value()?);
8628 }
8629 }
8630 }
8631 Ok(values_node::ExprTuple {
8632 cells: cells__.unwrap_or_default(),
8633 })
8634 }
8635 }
8636 deserializer.deserialize_struct("batch_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
8637 }
8638}
8639impl serde::Serialize for VectorIndexNearestNode {
8640 #[allow(deprecated)]
8641 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8642 where
8643 S: serde::Serializer,
8644 {
8645 use serde::ser::SerializeStruct;
8646 let mut len = 0;
8647 if self.reader_desc.is_some() {
8648 len += 1;
8649 }
8650 if self.vector_column_idx != 0 {
8651 len += 1;
8652 }
8653 if self.query_epoch.is_some() {
8654 len += 1;
8655 }
8656 let mut struct_ser = serializer.serialize_struct("batch_plan.VectorIndexNearestNode", len)?;
8657 if let Some(v) = self.reader_desc.as_ref() {
8658 struct_ser.serialize_field("readerDesc", v)?;
8659 }
8660 if self.vector_column_idx != 0 {
8661 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
8662 }
8663 if let Some(v) = self.query_epoch.as_ref() {
8664 struct_ser.serialize_field("queryEpoch", v)?;
8665 }
8666 struct_ser.end()
8667 }
8668}
8669impl<'de> serde::Deserialize<'de> for VectorIndexNearestNode {
8670 #[allow(deprecated)]
8671 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8672 where
8673 D: serde::Deserializer<'de>,
8674 {
8675 const FIELDS: &[&str] = &[
8676 "reader_desc",
8677 "readerDesc",
8678 "vector_column_idx",
8679 "vectorColumnIdx",
8680 "query_epoch",
8681 "queryEpoch",
8682 ];
8683
8684 #[allow(clippy::enum_variant_names)]
8685 enum GeneratedField {
8686 ReaderDesc,
8687 VectorColumnIdx,
8688 QueryEpoch,
8689 }
8690 impl<'de> serde::Deserialize<'de> for GeneratedField {
8691 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8692 where
8693 D: serde::Deserializer<'de>,
8694 {
8695 struct GeneratedVisitor;
8696
8697 impl serde::de::Visitor<'_> for GeneratedVisitor {
8698 type Value = GeneratedField;
8699
8700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8701 write!(formatter, "expected one of: {:?}", &FIELDS)
8702 }
8703
8704 #[allow(unused_variables)]
8705 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8706 where
8707 E: serde::de::Error,
8708 {
8709 match value {
8710 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
8711 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
8712 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
8713 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8714 }
8715 }
8716 }
8717 deserializer.deserialize_identifier(GeneratedVisitor)
8718 }
8719 }
8720 struct GeneratedVisitor;
8721 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8722 type Value = VectorIndexNearestNode;
8723
8724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8725 formatter.write_str("struct batch_plan.VectorIndexNearestNode")
8726 }
8727
8728 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexNearestNode, V::Error>
8729 where
8730 V: serde::de::MapAccess<'de>,
8731 {
8732 let mut reader_desc__ = None;
8733 let mut vector_column_idx__ = None;
8734 let mut query_epoch__ = None;
8735 while let Some(k) = map_.next_key()? {
8736 match k {
8737 GeneratedField::ReaderDesc => {
8738 if reader_desc__.is_some() {
8739 return Err(serde::de::Error::duplicate_field("readerDesc"));
8740 }
8741 reader_desc__ = map_.next_value()?;
8742 }
8743 GeneratedField::VectorColumnIdx => {
8744 if vector_column_idx__.is_some() {
8745 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
8746 }
8747 vector_column_idx__ =
8748 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8749 ;
8750 }
8751 GeneratedField::QueryEpoch => {
8752 if query_epoch__.is_some() {
8753 return Err(serde::de::Error::duplicate_field("queryEpoch"));
8754 }
8755 query_epoch__ = map_.next_value()?;
8756 }
8757 }
8758 }
8759 Ok(VectorIndexNearestNode {
8760 reader_desc: reader_desc__,
8761 vector_column_idx: vector_column_idx__.unwrap_or_default(),
8762 query_epoch: query_epoch__,
8763 })
8764 }
8765 }
8766 deserializer.deserialize_struct("batch_plan.VectorIndexNearestNode", FIELDS, GeneratedVisitor)
8767 }
8768}