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 MssqlQueryNode {
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 if self.encrypt {
4917 len += 1;
4918 }
4919 if self.trust_cert {
4920 len += 1;
4921 }
4922 let mut struct_ser = serializer.serialize_struct("batch_plan.MssqlQueryNode", len)?;
4923 if !self.columns.is_empty() {
4924 struct_ser.serialize_field("columns", &self.columns)?;
4925 }
4926 if !self.hostname.is_empty() {
4927 struct_ser.serialize_field("hostname", &self.hostname)?;
4928 }
4929 if !self.port.is_empty() {
4930 struct_ser.serialize_field("port", &self.port)?;
4931 }
4932 if !self.username.is_empty() {
4933 struct_ser.serialize_field("username", &self.username)?;
4934 }
4935 if !self.password.is_empty() {
4936 struct_ser.serialize_field("password", &self.password)?;
4937 }
4938 if !self.database.is_empty() {
4939 struct_ser.serialize_field("database", &self.database)?;
4940 }
4941 if !self.query.is_empty() {
4942 struct_ser.serialize_field("query", &self.query)?;
4943 }
4944 if self.encrypt {
4945 struct_ser.serialize_field("encrypt", &self.encrypt)?;
4946 }
4947 if self.trust_cert {
4948 struct_ser.serialize_field("trustCert", &self.trust_cert)?;
4949 }
4950 struct_ser.end()
4951 }
4952}
4953impl<'de> serde::Deserialize<'de> for MssqlQueryNode {
4954 #[allow(deprecated)]
4955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4956 where
4957 D: serde::Deserializer<'de>,
4958 {
4959 const FIELDS: &[&str] = &[
4960 "columns",
4961 "hostname",
4962 "port",
4963 "username",
4964 "password",
4965 "database",
4966 "query",
4967 "encrypt",
4968 "trust_cert",
4969 "trustCert",
4970 ];
4971
4972 #[allow(clippy::enum_variant_names)]
4973 enum GeneratedField {
4974 Columns,
4975 Hostname,
4976 Port,
4977 Username,
4978 Password,
4979 Database,
4980 Query,
4981 Encrypt,
4982 TrustCert,
4983 }
4984 impl<'de> serde::Deserialize<'de> for GeneratedField {
4985 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4986 where
4987 D: serde::Deserializer<'de>,
4988 {
4989 struct GeneratedVisitor;
4990
4991 impl serde::de::Visitor<'_> for GeneratedVisitor {
4992 type Value = GeneratedField;
4993
4994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4995 write!(formatter, "expected one of: {:?}", &FIELDS)
4996 }
4997
4998 #[allow(unused_variables)]
4999 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5000 where
5001 E: serde::de::Error,
5002 {
5003 match value {
5004 "columns" => Ok(GeneratedField::Columns),
5005 "hostname" => Ok(GeneratedField::Hostname),
5006 "port" => Ok(GeneratedField::Port),
5007 "username" => Ok(GeneratedField::Username),
5008 "password" => Ok(GeneratedField::Password),
5009 "database" => Ok(GeneratedField::Database),
5010 "query" => Ok(GeneratedField::Query),
5011 "encrypt" => Ok(GeneratedField::Encrypt),
5012 "trustCert" | "trust_cert" => Ok(GeneratedField::TrustCert),
5013 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5014 }
5015 }
5016 }
5017 deserializer.deserialize_identifier(GeneratedVisitor)
5018 }
5019 }
5020 struct GeneratedVisitor;
5021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5022 type Value = MssqlQueryNode;
5023
5024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5025 formatter.write_str("struct batch_plan.MssqlQueryNode")
5026 }
5027
5028 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MssqlQueryNode, V::Error>
5029 where
5030 V: serde::de::MapAccess<'de>,
5031 {
5032 let mut columns__ = None;
5033 let mut hostname__ = None;
5034 let mut port__ = None;
5035 let mut username__ = None;
5036 let mut password__ = None;
5037 let mut database__ = None;
5038 let mut query__ = None;
5039 let mut encrypt__ = None;
5040 let mut trust_cert__ = None;
5041 while let Some(k) = map_.next_key()? {
5042 match k {
5043 GeneratedField::Columns => {
5044 if columns__.is_some() {
5045 return Err(serde::de::Error::duplicate_field("columns"));
5046 }
5047 columns__ = Some(map_.next_value()?);
5048 }
5049 GeneratedField::Hostname => {
5050 if hostname__.is_some() {
5051 return Err(serde::de::Error::duplicate_field("hostname"));
5052 }
5053 hostname__ = Some(map_.next_value()?);
5054 }
5055 GeneratedField::Port => {
5056 if port__.is_some() {
5057 return Err(serde::de::Error::duplicate_field("port"));
5058 }
5059 port__ = Some(map_.next_value()?);
5060 }
5061 GeneratedField::Username => {
5062 if username__.is_some() {
5063 return Err(serde::de::Error::duplicate_field("username"));
5064 }
5065 username__ = Some(map_.next_value()?);
5066 }
5067 GeneratedField::Password => {
5068 if password__.is_some() {
5069 return Err(serde::de::Error::duplicate_field("password"));
5070 }
5071 password__ = Some(map_.next_value()?);
5072 }
5073 GeneratedField::Database => {
5074 if database__.is_some() {
5075 return Err(serde::de::Error::duplicate_field("database"));
5076 }
5077 database__ = Some(map_.next_value()?);
5078 }
5079 GeneratedField::Query => {
5080 if query__.is_some() {
5081 return Err(serde::de::Error::duplicate_field("query"));
5082 }
5083 query__ = Some(map_.next_value()?);
5084 }
5085 GeneratedField::Encrypt => {
5086 if encrypt__.is_some() {
5087 return Err(serde::de::Error::duplicate_field("encrypt"));
5088 }
5089 encrypt__ = Some(map_.next_value()?);
5090 }
5091 GeneratedField::TrustCert => {
5092 if trust_cert__.is_some() {
5093 return Err(serde::de::Error::duplicate_field("trustCert"));
5094 }
5095 trust_cert__ = Some(map_.next_value()?);
5096 }
5097 }
5098 }
5099 Ok(MssqlQueryNode {
5100 columns: columns__.unwrap_or_default(),
5101 hostname: hostname__.unwrap_or_default(),
5102 port: port__.unwrap_or_default(),
5103 username: username__.unwrap_or_default(),
5104 password: password__.unwrap_or_default(),
5105 database: database__.unwrap_or_default(),
5106 query: query__.unwrap_or_default(),
5107 encrypt: encrypt__.unwrap_or_default(),
5108 trust_cert: trust_cert__.unwrap_or_default(),
5109 })
5110 }
5111 }
5112 deserializer.deserialize_struct("batch_plan.MssqlQueryNode", FIELDS, GeneratedVisitor)
5113 }
5114}
5115impl serde::Serialize for MySqlQueryNode {
5116 #[allow(deprecated)]
5117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5118 where
5119 S: serde::Serializer,
5120 {
5121 use serde::ser::SerializeStruct;
5122 let mut len = 0;
5123 if !self.columns.is_empty() {
5124 len += 1;
5125 }
5126 if !self.hostname.is_empty() {
5127 len += 1;
5128 }
5129 if !self.port.is_empty() {
5130 len += 1;
5131 }
5132 if !self.username.is_empty() {
5133 len += 1;
5134 }
5135 if !self.password.is_empty() {
5136 len += 1;
5137 }
5138 if !self.database.is_empty() {
5139 len += 1;
5140 }
5141 if !self.query.is_empty() {
5142 len += 1;
5143 }
5144 let mut struct_ser = serializer.serialize_struct("batch_plan.MySqlQueryNode", len)?;
5145 if !self.columns.is_empty() {
5146 struct_ser.serialize_field("columns", &self.columns)?;
5147 }
5148 if !self.hostname.is_empty() {
5149 struct_ser.serialize_field("hostname", &self.hostname)?;
5150 }
5151 if !self.port.is_empty() {
5152 struct_ser.serialize_field("port", &self.port)?;
5153 }
5154 if !self.username.is_empty() {
5155 struct_ser.serialize_field("username", &self.username)?;
5156 }
5157 if !self.password.is_empty() {
5158 struct_ser.serialize_field("password", &self.password)?;
5159 }
5160 if !self.database.is_empty() {
5161 struct_ser.serialize_field("database", &self.database)?;
5162 }
5163 if !self.query.is_empty() {
5164 struct_ser.serialize_field("query", &self.query)?;
5165 }
5166 struct_ser.end()
5167 }
5168}
5169impl<'de> serde::Deserialize<'de> for MySqlQueryNode {
5170 #[allow(deprecated)]
5171 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5172 where
5173 D: serde::Deserializer<'de>,
5174 {
5175 const FIELDS: &[&str] = &[
5176 "columns",
5177 "hostname",
5178 "port",
5179 "username",
5180 "password",
5181 "database",
5182 "query",
5183 ];
5184
5185 #[allow(clippy::enum_variant_names)]
5186 enum GeneratedField {
5187 Columns,
5188 Hostname,
5189 Port,
5190 Username,
5191 Password,
5192 Database,
5193 Query,
5194 }
5195 impl<'de> serde::Deserialize<'de> for GeneratedField {
5196 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5197 where
5198 D: serde::Deserializer<'de>,
5199 {
5200 struct GeneratedVisitor;
5201
5202 impl serde::de::Visitor<'_> for GeneratedVisitor {
5203 type Value = GeneratedField;
5204
5205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5206 write!(formatter, "expected one of: {:?}", &FIELDS)
5207 }
5208
5209 #[allow(unused_variables)]
5210 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5211 where
5212 E: serde::de::Error,
5213 {
5214 match value {
5215 "columns" => Ok(GeneratedField::Columns),
5216 "hostname" => Ok(GeneratedField::Hostname),
5217 "port" => Ok(GeneratedField::Port),
5218 "username" => Ok(GeneratedField::Username),
5219 "password" => Ok(GeneratedField::Password),
5220 "database" => Ok(GeneratedField::Database),
5221 "query" => Ok(GeneratedField::Query),
5222 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5223 }
5224 }
5225 }
5226 deserializer.deserialize_identifier(GeneratedVisitor)
5227 }
5228 }
5229 struct GeneratedVisitor;
5230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5231 type Value = MySqlQueryNode;
5232
5233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5234 formatter.write_str("struct batch_plan.MySqlQueryNode")
5235 }
5236
5237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MySqlQueryNode, V::Error>
5238 where
5239 V: serde::de::MapAccess<'de>,
5240 {
5241 let mut columns__ = None;
5242 let mut hostname__ = None;
5243 let mut port__ = None;
5244 let mut username__ = None;
5245 let mut password__ = None;
5246 let mut database__ = None;
5247 let mut query__ = None;
5248 while let Some(k) = map_.next_key()? {
5249 match k {
5250 GeneratedField::Columns => {
5251 if columns__.is_some() {
5252 return Err(serde::de::Error::duplicate_field("columns"));
5253 }
5254 columns__ = Some(map_.next_value()?);
5255 }
5256 GeneratedField::Hostname => {
5257 if hostname__.is_some() {
5258 return Err(serde::de::Error::duplicate_field("hostname"));
5259 }
5260 hostname__ = Some(map_.next_value()?);
5261 }
5262 GeneratedField::Port => {
5263 if port__.is_some() {
5264 return Err(serde::de::Error::duplicate_field("port"));
5265 }
5266 port__ = Some(map_.next_value()?);
5267 }
5268 GeneratedField::Username => {
5269 if username__.is_some() {
5270 return Err(serde::de::Error::duplicate_field("username"));
5271 }
5272 username__ = Some(map_.next_value()?);
5273 }
5274 GeneratedField::Password => {
5275 if password__.is_some() {
5276 return Err(serde::de::Error::duplicate_field("password"));
5277 }
5278 password__ = Some(map_.next_value()?);
5279 }
5280 GeneratedField::Database => {
5281 if database__.is_some() {
5282 return Err(serde::de::Error::duplicate_field("database"));
5283 }
5284 database__ = Some(map_.next_value()?);
5285 }
5286 GeneratedField::Query => {
5287 if query__.is_some() {
5288 return Err(serde::de::Error::duplicate_field("query"));
5289 }
5290 query__ = Some(map_.next_value()?);
5291 }
5292 }
5293 }
5294 Ok(MySqlQueryNode {
5295 columns: columns__.unwrap_or_default(),
5296 hostname: hostname__.unwrap_or_default(),
5297 port: port__.unwrap_or_default(),
5298 username: username__.unwrap_or_default(),
5299 password: password__.unwrap_or_default(),
5300 database: database__.unwrap_or_default(),
5301 query: query__.unwrap_or_default(),
5302 })
5303 }
5304 }
5305 deserializer.deserialize_struct("batch_plan.MySqlQueryNode", FIELDS, GeneratedVisitor)
5306 }
5307}
5308impl serde::Serialize for NestedLoopJoinNode {
5309 #[allow(deprecated)]
5310 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5311 where
5312 S: serde::Serializer,
5313 {
5314 use serde::ser::SerializeStruct;
5315 let mut len = 0;
5316 if self.join_type != 0 {
5317 len += 1;
5318 }
5319 if self.join_cond.is_some() {
5320 len += 1;
5321 }
5322 if !self.output_indices.is_empty() {
5323 len += 1;
5324 }
5325 let mut struct_ser = serializer.serialize_struct("batch_plan.NestedLoopJoinNode", len)?;
5326 if self.join_type != 0 {
5327 let v = super::plan_common::JoinType::try_from(self.join_type)
5328 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5329 struct_ser.serialize_field("joinType", &v)?;
5330 }
5331 if let Some(v) = self.join_cond.as_ref() {
5332 struct_ser.serialize_field("joinCond", v)?;
5333 }
5334 if !self.output_indices.is_empty() {
5335 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5336 }
5337 struct_ser.end()
5338 }
5339}
5340impl<'de> serde::Deserialize<'de> for NestedLoopJoinNode {
5341 #[allow(deprecated)]
5342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5343 where
5344 D: serde::Deserializer<'de>,
5345 {
5346 const FIELDS: &[&str] = &[
5347 "join_type",
5348 "joinType",
5349 "join_cond",
5350 "joinCond",
5351 "output_indices",
5352 "outputIndices",
5353 ];
5354
5355 #[allow(clippy::enum_variant_names)]
5356 enum GeneratedField {
5357 JoinType,
5358 JoinCond,
5359 OutputIndices,
5360 }
5361 impl<'de> serde::Deserialize<'de> for GeneratedField {
5362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5363 where
5364 D: serde::Deserializer<'de>,
5365 {
5366 struct GeneratedVisitor;
5367
5368 impl serde::de::Visitor<'_> for GeneratedVisitor {
5369 type Value = GeneratedField;
5370
5371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5372 write!(formatter, "expected one of: {:?}", &FIELDS)
5373 }
5374
5375 #[allow(unused_variables)]
5376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5377 where
5378 E: serde::de::Error,
5379 {
5380 match value {
5381 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5382 "joinCond" | "join_cond" => Ok(GeneratedField::JoinCond),
5383 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5385 }
5386 }
5387 }
5388 deserializer.deserialize_identifier(GeneratedVisitor)
5389 }
5390 }
5391 struct GeneratedVisitor;
5392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5393 type Value = NestedLoopJoinNode;
5394
5395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5396 formatter.write_str("struct batch_plan.NestedLoopJoinNode")
5397 }
5398
5399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NestedLoopJoinNode, V::Error>
5400 where
5401 V: serde::de::MapAccess<'de>,
5402 {
5403 let mut join_type__ = None;
5404 let mut join_cond__ = None;
5405 let mut output_indices__ = None;
5406 while let Some(k) = map_.next_key()? {
5407 match k {
5408 GeneratedField::JoinType => {
5409 if join_type__.is_some() {
5410 return Err(serde::de::Error::duplicate_field("joinType"));
5411 }
5412 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5413 }
5414 GeneratedField::JoinCond => {
5415 if join_cond__.is_some() {
5416 return Err(serde::de::Error::duplicate_field("joinCond"));
5417 }
5418 join_cond__ = map_.next_value()?;
5419 }
5420 GeneratedField::OutputIndices => {
5421 if output_indices__.is_some() {
5422 return Err(serde::de::Error::duplicate_field("outputIndices"));
5423 }
5424 output_indices__ =
5425 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5426 .into_iter().map(|x| x.0).collect())
5427 ;
5428 }
5429 }
5430 }
5431 Ok(NestedLoopJoinNode {
5432 join_type: join_type__.unwrap_or_default(),
5433 join_cond: join_cond__,
5434 output_indices: output_indices__.unwrap_or_default(),
5435 })
5436 }
5437 }
5438 deserializer.deserialize_struct("batch_plan.NestedLoopJoinNode", FIELDS, GeneratedVisitor)
5439 }
5440}
5441impl serde::Serialize for PlanFragment {
5442 #[allow(deprecated)]
5443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5444 where
5445 S: serde::Serializer,
5446 {
5447 use serde::ser::SerializeStruct;
5448 let mut len = 0;
5449 if self.root.is_some() {
5450 len += 1;
5451 }
5452 if self.exchange_info.is_some() {
5453 len += 1;
5454 }
5455 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanFragment", len)?;
5456 if let Some(v) = self.root.as_ref() {
5457 struct_ser.serialize_field("root", v)?;
5458 }
5459 if let Some(v) = self.exchange_info.as_ref() {
5460 struct_ser.serialize_field("exchangeInfo", v)?;
5461 }
5462 struct_ser.end()
5463 }
5464}
5465impl<'de> serde::Deserialize<'de> for PlanFragment {
5466 #[allow(deprecated)]
5467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5468 where
5469 D: serde::Deserializer<'de>,
5470 {
5471 const FIELDS: &[&str] = &[
5472 "root",
5473 "exchange_info",
5474 "exchangeInfo",
5475 ];
5476
5477 #[allow(clippy::enum_variant_names)]
5478 enum GeneratedField {
5479 Root,
5480 ExchangeInfo,
5481 }
5482 impl<'de> serde::Deserialize<'de> for GeneratedField {
5483 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5484 where
5485 D: serde::Deserializer<'de>,
5486 {
5487 struct GeneratedVisitor;
5488
5489 impl serde::de::Visitor<'_> for GeneratedVisitor {
5490 type Value = GeneratedField;
5491
5492 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5493 write!(formatter, "expected one of: {:?}", &FIELDS)
5494 }
5495
5496 #[allow(unused_variables)]
5497 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5498 where
5499 E: serde::de::Error,
5500 {
5501 match value {
5502 "root" => Ok(GeneratedField::Root),
5503 "exchangeInfo" | "exchange_info" => Ok(GeneratedField::ExchangeInfo),
5504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5505 }
5506 }
5507 }
5508 deserializer.deserialize_identifier(GeneratedVisitor)
5509 }
5510 }
5511 struct GeneratedVisitor;
5512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5513 type Value = PlanFragment;
5514
5515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5516 formatter.write_str("struct batch_plan.PlanFragment")
5517 }
5518
5519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanFragment, V::Error>
5520 where
5521 V: serde::de::MapAccess<'de>,
5522 {
5523 let mut root__ = None;
5524 let mut exchange_info__ = None;
5525 while let Some(k) = map_.next_key()? {
5526 match k {
5527 GeneratedField::Root => {
5528 if root__.is_some() {
5529 return Err(serde::de::Error::duplicate_field("root"));
5530 }
5531 root__ = map_.next_value()?;
5532 }
5533 GeneratedField::ExchangeInfo => {
5534 if exchange_info__.is_some() {
5535 return Err(serde::de::Error::duplicate_field("exchangeInfo"));
5536 }
5537 exchange_info__ = map_.next_value()?;
5538 }
5539 }
5540 }
5541 Ok(PlanFragment {
5542 root: root__,
5543 exchange_info: exchange_info__,
5544 })
5545 }
5546 }
5547 deserializer.deserialize_struct("batch_plan.PlanFragment", FIELDS, GeneratedVisitor)
5548 }
5549}
5550impl serde::Serialize for PlanNode {
5551 #[allow(deprecated)]
5552 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5553 where
5554 S: serde::Serializer,
5555 {
5556 use serde::ser::SerializeStruct;
5557 let mut len = 0;
5558 if !self.children.is_empty() {
5559 len += 1;
5560 }
5561 if !self.identity.is_empty() {
5562 len += 1;
5563 }
5564 if self.node_body.is_some() {
5565 len += 1;
5566 }
5567 let mut struct_ser = serializer.serialize_struct("batch_plan.PlanNode", len)?;
5568 if !self.children.is_empty() {
5569 struct_ser.serialize_field("children", &self.children)?;
5570 }
5571 if !self.identity.is_empty() {
5572 struct_ser.serialize_field("identity", &self.identity)?;
5573 }
5574 if let Some(v) = self.node_body.as_ref() {
5575 match v {
5576 plan_node::NodeBody::Insert(v) => {
5577 struct_ser.serialize_field("insert", v)?;
5578 }
5579 plan_node::NodeBody::Delete(v) => {
5580 struct_ser.serialize_field("delete", v)?;
5581 }
5582 plan_node::NodeBody::Update(v) => {
5583 struct_ser.serialize_field("update", v)?;
5584 }
5585 plan_node::NodeBody::Project(v) => {
5586 struct_ser.serialize_field("project", v)?;
5587 }
5588 plan_node::NodeBody::HashAgg(v) => {
5589 struct_ser.serialize_field("hashAgg", v)?;
5590 }
5591 plan_node::NodeBody::Filter(v) => {
5592 struct_ser.serialize_field("filter", v)?;
5593 }
5594 plan_node::NodeBody::Exchange(v) => {
5595 struct_ser.serialize_field("exchange", v)?;
5596 }
5597 plan_node::NodeBody::Sort(v) => {
5598 struct_ser.serialize_field("sort", v)?;
5599 }
5600 plan_node::NodeBody::NestedLoopJoin(v) => {
5601 struct_ser.serialize_field("nestedLoopJoin", v)?;
5602 }
5603 plan_node::NodeBody::TopN(v) => {
5604 struct_ser.serialize_field("topN", v)?;
5605 }
5606 plan_node::NodeBody::SortAgg(v) => {
5607 struct_ser.serialize_field("sortAgg", v)?;
5608 }
5609 plan_node::NodeBody::RowSeqScan(v) => {
5610 struct_ser.serialize_field("rowSeqScan", v)?;
5611 }
5612 plan_node::NodeBody::Limit(v) => {
5613 struct_ser.serialize_field("limit", v)?;
5614 }
5615 plan_node::NodeBody::Values(v) => {
5616 struct_ser.serialize_field("values", v)?;
5617 }
5618 plan_node::NodeBody::HashJoin(v) => {
5619 struct_ser.serialize_field("hashJoin", v)?;
5620 }
5621 plan_node::NodeBody::MergeSortExchange(v) => {
5622 struct_ser.serialize_field("mergeSortExchange", v)?;
5623 }
5624 plan_node::NodeBody::HopWindow(v) => {
5625 struct_ser.serialize_field("hopWindow", v)?;
5626 }
5627 plan_node::NodeBody::TableFunction(v) => {
5628 struct_ser.serialize_field("tableFunction", v)?;
5629 }
5630 plan_node::NodeBody::SysRowSeqScan(v) => {
5631 struct_ser.serialize_field("sysRowSeqScan", v)?;
5632 }
5633 plan_node::NodeBody::Expand(v) => {
5634 struct_ser.serialize_field("expand", v)?;
5635 }
5636 plan_node::NodeBody::LocalLookupJoin(v) => {
5637 struct_ser.serialize_field("localLookupJoin", v)?;
5638 }
5639 plan_node::NodeBody::ProjectSet(v) => {
5640 struct_ser.serialize_field("projectSet", v)?;
5641 }
5642 plan_node::NodeBody::Union(v) => {
5643 struct_ser.serialize_field("union", v)?;
5644 }
5645 plan_node::NodeBody::GroupTopN(v) => {
5646 struct_ser.serialize_field("groupTopN", v)?;
5647 }
5648 plan_node::NodeBody::DistributedLookupJoin(v) => {
5649 struct_ser.serialize_field("distributedLookupJoin", v)?;
5650 }
5651 plan_node::NodeBody::Source(v) => {
5652 struct_ser.serialize_field("source", v)?;
5653 }
5654 plan_node::NodeBody::SortOverWindow(v) => {
5655 struct_ser.serialize_field("sortOverWindow", v)?;
5656 }
5657 plan_node::NodeBody::MaxOneRow(v) => {
5658 struct_ser.serialize_field("maxOneRow", v)?;
5659 }
5660 plan_node::NodeBody::LogRowSeqScan(v) => {
5661 struct_ser.serialize_field("logRowSeqScan", v)?;
5662 }
5663 plan_node::NodeBody::FileScan(v) => {
5664 struct_ser.serialize_field("fileScan", v)?;
5665 }
5666 plan_node::NodeBody::IcebergScan(v) => {
5667 struct_ser.serialize_field("icebergScan", v)?;
5668 }
5669 plan_node::NodeBody::PostgresQuery(v) => {
5670 struct_ser.serialize_field("postgresQuery", v)?;
5671 }
5672 plan_node::NodeBody::MysqlQuery(v) => {
5673 struct_ser.serialize_field("mysqlQuery", v)?;
5674 }
5675 plan_node::NodeBody::GcsFileScan(v) => {
5676 struct_ser.serialize_field("gcsFileScan", v)?;
5677 }
5678 plan_node::NodeBody::AzblobFileScan(v) => {
5679 struct_ser.serialize_field("azblobFileScan", v)?;
5680 }
5681 plan_node::NodeBody::VectorIndexNearest(v) => {
5682 struct_ser.serialize_field("vectorIndexNearest", v)?;
5683 }
5684 plan_node::NodeBody::GetChannelDeltaStats(v) => {
5685 struct_ser.serialize_field("getChannelDeltaStats", v)?;
5686 }
5687 plan_node::NodeBody::IcebergMetadataScan(v) => {
5688 struct_ser.serialize_field("icebergMetadataScan", v)?;
5689 }
5690 plan_node::NodeBody::MssqlQuery(v) => {
5691 struct_ser.serialize_field("mssqlQuery", v)?;
5692 }
5693 plan_node::NodeBody::BlockExecutor(v) => {
5694 struct_ser.serialize_field("blockExecutor", v)?;
5695 }
5696 plan_node::NodeBody::BusyLoopExecutor(v) => {
5697 struct_ser.serialize_field("busyLoopExecutor", v)?;
5698 }
5699 }
5700 }
5701 struct_ser.end()
5702 }
5703}
5704impl<'de> serde::Deserialize<'de> for PlanNode {
5705 #[allow(deprecated)]
5706 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5707 where
5708 D: serde::Deserializer<'de>,
5709 {
5710 const FIELDS: &[&str] = &[
5711 "children",
5712 "identity",
5713 "insert",
5714 "delete",
5715 "update",
5716 "project",
5717 "hash_agg",
5718 "hashAgg",
5719 "filter",
5720 "exchange",
5721 "sort",
5722 "nested_loop_join",
5723 "nestedLoopJoin",
5724 "top_n",
5725 "topN",
5726 "sort_agg",
5727 "sortAgg",
5728 "row_seq_scan",
5729 "rowSeqScan",
5730 "limit",
5731 "values",
5732 "hash_join",
5733 "hashJoin",
5734 "merge_sort_exchange",
5735 "mergeSortExchange",
5736 "hop_window",
5737 "hopWindow",
5738 "table_function",
5739 "tableFunction",
5740 "sys_row_seq_scan",
5741 "sysRowSeqScan",
5742 "expand",
5743 "local_lookup_join",
5744 "localLookupJoin",
5745 "project_set",
5746 "projectSet",
5747 "union",
5748 "group_top_n",
5749 "groupTopN",
5750 "distributed_lookup_join",
5751 "distributedLookupJoin",
5752 "source",
5753 "sort_over_window",
5754 "sortOverWindow",
5755 "max_one_row",
5756 "maxOneRow",
5757 "log_row_seq_scan",
5758 "logRowSeqScan",
5759 "file_scan",
5760 "fileScan",
5761 "iceberg_scan",
5762 "icebergScan",
5763 "postgres_query",
5764 "postgresQuery",
5765 "mysql_query",
5766 "mysqlQuery",
5767 "gcs_file_scan",
5768 "gcsFileScan",
5769 "azblob_file_scan",
5770 "azblobFileScan",
5771 "vector_index_nearest",
5772 "vectorIndexNearest",
5773 "get_channel_delta_stats",
5774 "getChannelDeltaStats",
5775 "iceberg_metadata_scan",
5776 "icebergMetadataScan",
5777 "mssql_query",
5778 "mssqlQuery",
5779 "block_executor",
5780 "blockExecutor",
5781 "busy_loop_executor",
5782 "busyLoopExecutor",
5783 ];
5784
5785 #[allow(clippy::enum_variant_names)]
5786 enum GeneratedField {
5787 Children,
5788 Identity,
5789 Insert,
5790 Delete,
5791 Update,
5792 Project,
5793 HashAgg,
5794 Filter,
5795 Exchange,
5796 Sort,
5797 NestedLoopJoin,
5798 TopN,
5799 SortAgg,
5800 RowSeqScan,
5801 Limit,
5802 Values,
5803 HashJoin,
5804 MergeSortExchange,
5805 HopWindow,
5806 TableFunction,
5807 SysRowSeqScan,
5808 Expand,
5809 LocalLookupJoin,
5810 ProjectSet,
5811 Union,
5812 GroupTopN,
5813 DistributedLookupJoin,
5814 Source,
5815 SortOverWindow,
5816 MaxOneRow,
5817 LogRowSeqScan,
5818 FileScan,
5819 IcebergScan,
5820 PostgresQuery,
5821 MysqlQuery,
5822 GcsFileScan,
5823 AzblobFileScan,
5824 VectorIndexNearest,
5825 GetChannelDeltaStats,
5826 IcebergMetadataScan,
5827 MssqlQuery,
5828 BlockExecutor,
5829 BusyLoopExecutor,
5830 }
5831 impl<'de> serde::Deserialize<'de> for GeneratedField {
5832 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5833 where
5834 D: serde::Deserializer<'de>,
5835 {
5836 struct GeneratedVisitor;
5837
5838 impl serde::de::Visitor<'_> for GeneratedVisitor {
5839 type Value = GeneratedField;
5840
5841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5842 write!(formatter, "expected one of: {:?}", &FIELDS)
5843 }
5844
5845 #[allow(unused_variables)]
5846 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5847 where
5848 E: serde::de::Error,
5849 {
5850 match value {
5851 "children" => Ok(GeneratedField::Children),
5852 "identity" => Ok(GeneratedField::Identity),
5853 "insert" => Ok(GeneratedField::Insert),
5854 "delete" => Ok(GeneratedField::Delete),
5855 "update" => Ok(GeneratedField::Update),
5856 "project" => Ok(GeneratedField::Project),
5857 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
5858 "filter" => Ok(GeneratedField::Filter),
5859 "exchange" => Ok(GeneratedField::Exchange),
5860 "sort" => Ok(GeneratedField::Sort),
5861 "nestedLoopJoin" | "nested_loop_join" => Ok(GeneratedField::NestedLoopJoin),
5862 "topN" | "top_n" => Ok(GeneratedField::TopN),
5863 "sortAgg" | "sort_agg" => Ok(GeneratedField::SortAgg),
5864 "rowSeqScan" | "row_seq_scan" => Ok(GeneratedField::RowSeqScan),
5865 "limit" => Ok(GeneratedField::Limit),
5866 "values" => Ok(GeneratedField::Values),
5867 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
5868 "mergeSortExchange" | "merge_sort_exchange" => Ok(GeneratedField::MergeSortExchange),
5869 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
5870 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
5871 "sysRowSeqScan" | "sys_row_seq_scan" => Ok(GeneratedField::SysRowSeqScan),
5872 "expand" => Ok(GeneratedField::Expand),
5873 "localLookupJoin" | "local_lookup_join" => Ok(GeneratedField::LocalLookupJoin),
5874 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
5875 "union" => Ok(GeneratedField::Union),
5876 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
5877 "distributedLookupJoin" | "distributed_lookup_join" => Ok(GeneratedField::DistributedLookupJoin),
5878 "source" => Ok(GeneratedField::Source),
5879 "sortOverWindow" | "sort_over_window" => Ok(GeneratedField::SortOverWindow),
5880 "maxOneRow" | "max_one_row" => Ok(GeneratedField::MaxOneRow),
5881 "logRowSeqScan" | "log_row_seq_scan" => Ok(GeneratedField::LogRowSeqScan),
5882 "fileScan" | "file_scan" => Ok(GeneratedField::FileScan),
5883 "icebergScan" | "iceberg_scan" => Ok(GeneratedField::IcebergScan),
5884 "postgresQuery" | "postgres_query" => Ok(GeneratedField::PostgresQuery),
5885 "mysqlQuery" | "mysql_query" => Ok(GeneratedField::MysqlQuery),
5886 "gcsFileScan" | "gcs_file_scan" => Ok(GeneratedField::GcsFileScan),
5887 "azblobFileScan" | "azblob_file_scan" => Ok(GeneratedField::AzblobFileScan),
5888 "vectorIndexNearest" | "vector_index_nearest" => Ok(GeneratedField::VectorIndexNearest),
5889 "getChannelDeltaStats" | "get_channel_delta_stats" => Ok(GeneratedField::GetChannelDeltaStats),
5890 "icebergMetadataScan" | "iceberg_metadata_scan" => Ok(GeneratedField::IcebergMetadataScan),
5891 "mssqlQuery" | "mssql_query" => Ok(GeneratedField::MssqlQuery),
5892 "blockExecutor" | "block_executor" => Ok(GeneratedField::BlockExecutor),
5893 "busyLoopExecutor" | "busy_loop_executor" => Ok(GeneratedField::BusyLoopExecutor),
5894 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5895 }
5896 }
5897 }
5898 deserializer.deserialize_identifier(GeneratedVisitor)
5899 }
5900 }
5901 struct GeneratedVisitor;
5902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5903 type Value = PlanNode;
5904
5905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5906 formatter.write_str("struct batch_plan.PlanNode")
5907 }
5908
5909 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanNode, V::Error>
5910 where
5911 V: serde::de::MapAccess<'de>,
5912 {
5913 let mut children__ = None;
5914 let mut identity__ = None;
5915 let mut node_body__ = None;
5916 while let Some(k) = map_.next_key()? {
5917 match k {
5918 GeneratedField::Children => {
5919 if children__.is_some() {
5920 return Err(serde::de::Error::duplicate_field("children"));
5921 }
5922 children__ = Some(map_.next_value()?);
5923 }
5924 GeneratedField::Identity => {
5925 if identity__.is_some() {
5926 return Err(serde::de::Error::duplicate_field("identity"));
5927 }
5928 identity__ = Some(map_.next_value()?);
5929 }
5930 GeneratedField::Insert => {
5931 if node_body__.is_some() {
5932 return Err(serde::de::Error::duplicate_field("insert"));
5933 }
5934 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Insert)
5935;
5936 }
5937 GeneratedField::Delete => {
5938 if node_body__.is_some() {
5939 return Err(serde::de::Error::duplicate_field("delete"));
5940 }
5941 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Delete)
5942;
5943 }
5944 GeneratedField::Update => {
5945 if node_body__.is_some() {
5946 return Err(serde::de::Error::duplicate_field("update"));
5947 }
5948 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Update)
5949;
5950 }
5951 GeneratedField::Project => {
5952 if node_body__.is_some() {
5953 return Err(serde::de::Error::duplicate_field("project"));
5954 }
5955 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Project)
5956;
5957 }
5958 GeneratedField::HashAgg => {
5959 if node_body__.is_some() {
5960 return Err(serde::de::Error::duplicate_field("hashAgg"));
5961 }
5962 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashAgg)
5963;
5964 }
5965 GeneratedField::Filter => {
5966 if node_body__.is_some() {
5967 return Err(serde::de::Error::duplicate_field("filter"));
5968 }
5969 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Filter)
5970;
5971 }
5972 GeneratedField::Exchange => {
5973 if node_body__.is_some() {
5974 return Err(serde::de::Error::duplicate_field("exchange"));
5975 }
5976 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Exchange)
5977;
5978 }
5979 GeneratedField::Sort => {
5980 if node_body__.is_some() {
5981 return Err(serde::de::Error::duplicate_field("sort"));
5982 }
5983 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Sort)
5984;
5985 }
5986 GeneratedField::NestedLoopJoin => {
5987 if node_body__.is_some() {
5988 return Err(serde::de::Error::duplicate_field("nestedLoopJoin"));
5989 }
5990 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::NestedLoopJoin)
5991;
5992 }
5993 GeneratedField::TopN => {
5994 if node_body__.is_some() {
5995 return Err(serde::de::Error::duplicate_field("topN"));
5996 }
5997 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TopN)
5998;
5999 }
6000 GeneratedField::SortAgg => {
6001 if node_body__.is_some() {
6002 return Err(serde::de::Error::duplicate_field("sortAgg"));
6003 }
6004 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortAgg)
6005;
6006 }
6007 GeneratedField::RowSeqScan => {
6008 if node_body__.is_some() {
6009 return Err(serde::de::Error::duplicate_field("rowSeqScan"));
6010 }
6011 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::RowSeqScan)
6012;
6013 }
6014 GeneratedField::Limit => {
6015 if node_body__.is_some() {
6016 return Err(serde::de::Error::duplicate_field("limit"));
6017 }
6018 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Limit)
6019;
6020 }
6021 GeneratedField::Values => {
6022 if node_body__.is_some() {
6023 return Err(serde::de::Error::duplicate_field("values"));
6024 }
6025 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Values)
6026;
6027 }
6028 GeneratedField::HashJoin => {
6029 if node_body__.is_some() {
6030 return Err(serde::de::Error::duplicate_field("hashJoin"));
6031 }
6032 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashJoin)
6033;
6034 }
6035 GeneratedField::MergeSortExchange => {
6036 if node_body__.is_some() {
6037 return Err(serde::de::Error::duplicate_field("mergeSortExchange"));
6038 }
6039 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MergeSortExchange)
6040;
6041 }
6042 GeneratedField::HopWindow => {
6043 if node_body__.is_some() {
6044 return Err(serde::de::Error::duplicate_field("hopWindow"));
6045 }
6046 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HopWindow)
6047;
6048 }
6049 GeneratedField::TableFunction => {
6050 if node_body__.is_some() {
6051 return Err(serde::de::Error::duplicate_field("tableFunction"));
6052 }
6053 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TableFunction)
6054;
6055 }
6056 GeneratedField::SysRowSeqScan => {
6057 if node_body__.is_some() {
6058 return Err(serde::de::Error::duplicate_field("sysRowSeqScan"));
6059 }
6060 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SysRowSeqScan)
6061;
6062 }
6063 GeneratedField::Expand => {
6064 if node_body__.is_some() {
6065 return Err(serde::de::Error::duplicate_field("expand"));
6066 }
6067 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Expand)
6068;
6069 }
6070 GeneratedField::LocalLookupJoin => {
6071 if node_body__.is_some() {
6072 return Err(serde::de::Error::duplicate_field("localLookupJoin"));
6073 }
6074 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LocalLookupJoin)
6075;
6076 }
6077 GeneratedField::ProjectSet => {
6078 if node_body__.is_some() {
6079 return Err(serde::de::Error::duplicate_field("projectSet"));
6080 }
6081 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::ProjectSet)
6082;
6083 }
6084 GeneratedField::Union => {
6085 if node_body__.is_some() {
6086 return Err(serde::de::Error::duplicate_field("union"));
6087 }
6088 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Union)
6089;
6090 }
6091 GeneratedField::GroupTopN => {
6092 if node_body__.is_some() {
6093 return Err(serde::de::Error::duplicate_field("groupTopN"));
6094 }
6095 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GroupTopN)
6096;
6097 }
6098 GeneratedField::DistributedLookupJoin => {
6099 if node_body__.is_some() {
6100 return Err(serde::de::Error::duplicate_field("distributedLookupJoin"));
6101 }
6102 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::DistributedLookupJoin)
6103;
6104 }
6105 GeneratedField::Source => {
6106 if node_body__.is_some() {
6107 return Err(serde::de::Error::duplicate_field("source"));
6108 }
6109 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Source)
6110;
6111 }
6112 GeneratedField::SortOverWindow => {
6113 if node_body__.is_some() {
6114 return Err(serde::de::Error::duplicate_field("sortOverWindow"));
6115 }
6116 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortOverWindow)
6117;
6118 }
6119 GeneratedField::MaxOneRow => {
6120 if node_body__.is_some() {
6121 return Err(serde::de::Error::duplicate_field("maxOneRow"));
6122 }
6123 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MaxOneRow)
6124;
6125 }
6126 GeneratedField::LogRowSeqScan => {
6127 if node_body__.is_some() {
6128 return Err(serde::de::Error::duplicate_field("logRowSeqScan"));
6129 }
6130 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LogRowSeqScan)
6131;
6132 }
6133 GeneratedField::FileScan => {
6134 if node_body__.is_some() {
6135 return Err(serde::de::Error::duplicate_field("fileScan"));
6136 }
6137 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::FileScan)
6138;
6139 }
6140 GeneratedField::IcebergScan => {
6141 if node_body__.is_some() {
6142 return Err(serde::de::Error::duplicate_field("icebergScan"));
6143 }
6144 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergScan)
6145;
6146 }
6147 GeneratedField::PostgresQuery => {
6148 if node_body__.is_some() {
6149 return Err(serde::de::Error::duplicate_field("postgresQuery"));
6150 }
6151 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::PostgresQuery)
6152;
6153 }
6154 GeneratedField::MysqlQuery => {
6155 if node_body__.is_some() {
6156 return Err(serde::de::Error::duplicate_field("mysqlQuery"));
6157 }
6158 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MysqlQuery)
6159;
6160 }
6161 GeneratedField::GcsFileScan => {
6162 if node_body__.is_some() {
6163 return Err(serde::de::Error::duplicate_field("gcsFileScan"));
6164 }
6165 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GcsFileScan)
6166;
6167 }
6168 GeneratedField::AzblobFileScan => {
6169 if node_body__.is_some() {
6170 return Err(serde::de::Error::duplicate_field("azblobFileScan"));
6171 }
6172 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::AzblobFileScan)
6173;
6174 }
6175 GeneratedField::VectorIndexNearest => {
6176 if node_body__.is_some() {
6177 return Err(serde::de::Error::duplicate_field("vectorIndexNearest"));
6178 }
6179 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::VectorIndexNearest)
6180;
6181 }
6182 GeneratedField::GetChannelDeltaStats => {
6183 if node_body__.is_some() {
6184 return Err(serde::de::Error::duplicate_field("getChannelDeltaStats"));
6185 }
6186 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GetChannelDeltaStats)
6187;
6188 }
6189 GeneratedField::IcebergMetadataScan => {
6190 if node_body__.is_some() {
6191 return Err(serde::de::Error::duplicate_field("icebergMetadataScan"));
6192 }
6193 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergMetadataScan)
6194;
6195 }
6196 GeneratedField::MssqlQuery => {
6197 if node_body__.is_some() {
6198 return Err(serde::de::Error::duplicate_field("mssqlQuery"));
6199 }
6200 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MssqlQuery)
6201;
6202 }
6203 GeneratedField::BlockExecutor => {
6204 if node_body__.is_some() {
6205 return Err(serde::de::Error::duplicate_field("blockExecutor"));
6206 }
6207 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BlockExecutor);
6208 }
6209 GeneratedField::BusyLoopExecutor => {
6210 if node_body__.is_some() {
6211 return Err(serde::de::Error::duplicate_field("busyLoopExecutor"));
6212 }
6213 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BusyLoopExecutor);
6214 }
6215 }
6216 }
6217 Ok(PlanNode {
6218 children: children__.unwrap_or_default(),
6219 identity: identity__.unwrap_or_default(),
6220 node_body: node_body__,
6221 })
6222 }
6223 }
6224 deserializer.deserialize_struct("batch_plan.PlanNode", FIELDS, GeneratedVisitor)
6225 }
6226}
6227impl serde::Serialize for PostgresQueryNode {
6228 #[allow(deprecated)]
6229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6230 where
6231 S: serde::Serializer,
6232 {
6233 use serde::ser::SerializeStruct;
6234 let mut len = 0;
6235 if !self.columns.is_empty() {
6236 len += 1;
6237 }
6238 if !self.hostname.is_empty() {
6239 len += 1;
6240 }
6241 if !self.port.is_empty() {
6242 len += 1;
6243 }
6244 if !self.username.is_empty() {
6245 len += 1;
6246 }
6247 if !self.password.is_empty() {
6248 len += 1;
6249 }
6250 if !self.database.is_empty() {
6251 len += 1;
6252 }
6253 if !self.query.is_empty() {
6254 len += 1;
6255 }
6256 if !self.ssl_mode.is_empty() {
6257 len += 1;
6258 }
6259 if !self.ssl_root_cert.is_empty() {
6260 len += 1;
6261 }
6262 let mut struct_ser = serializer.serialize_struct("batch_plan.PostgresQueryNode", len)?;
6263 if !self.columns.is_empty() {
6264 struct_ser.serialize_field("columns", &self.columns)?;
6265 }
6266 if !self.hostname.is_empty() {
6267 struct_ser.serialize_field("hostname", &self.hostname)?;
6268 }
6269 if !self.port.is_empty() {
6270 struct_ser.serialize_field("port", &self.port)?;
6271 }
6272 if !self.username.is_empty() {
6273 struct_ser.serialize_field("username", &self.username)?;
6274 }
6275 if !self.password.is_empty() {
6276 struct_ser.serialize_field("password", &self.password)?;
6277 }
6278 if !self.database.is_empty() {
6279 struct_ser.serialize_field("database", &self.database)?;
6280 }
6281 if !self.query.is_empty() {
6282 struct_ser.serialize_field("query", &self.query)?;
6283 }
6284 if !self.ssl_mode.is_empty() {
6285 struct_ser.serialize_field("sslMode", &self.ssl_mode)?;
6286 }
6287 if !self.ssl_root_cert.is_empty() {
6288 struct_ser.serialize_field("sslRootCert", &self.ssl_root_cert)?;
6289 }
6290 struct_ser.end()
6291 }
6292}
6293impl<'de> serde::Deserialize<'de> for PostgresQueryNode {
6294 #[allow(deprecated)]
6295 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6296 where
6297 D: serde::Deserializer<'de>,
6298 {
6299 const FIELDS: &[&str] = &[
6300 "columns",
6301 "hostname",
6302 "port",
6303 "username",
6304 "password",
6305 "database",
6306 "query",
6307 "ssl_mode",
6308 "sslMode",
6309 "ssl_root_cert",
6310 "sslRootCert",
6311 ];
6312
6313 #[allow(clippy::enum_variant_names)]
6314 enum GeneratedField {
6315 Columns,
6316 Hostname,
6317 Port,
6318 Username,
6319 Password,
6320 Database,
6321 Query,
6322 SslMode,
6323 SslRootCert,
6324 }
6325 impl<'de> serde::Deserialize<'de> for GeneratedField {
6326 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6327 where
6328 D: serde::Deserializer<'de>,
6329 {
6330 struct GeneratedVisitor;
6331
6332 impl serde::de::Visitor<'_> for GeneratedVisitor {
6333 type Value = GeneratedField;
6334
6335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6336 write!(formatter, "expected one of: {:?}", &FIELDS)
6337 }
6338
6339 #[allow(unused_variables)]
6340 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6341 where
6342 E: serde::de::Error,
6343 {
6344 match value {
6345 "columns" => Ok(GeneratedField::Columns),
6346 "hostname" => Ok(GeneratedField::Hostname),
6347 "port" => Ok(GeneratedField::Port),
6348 "username" => Ok(GeneratedField::Username),
6349 "password" => Ok(GeneratedField::Password),
6350 "database" => Ok(GeneratedField::Database),
6351 "query" => Ok(GeneratedField::Query),
6352 "sslMode" | "ssl_mode" => Ok(GeneratedField::SslMode),
6353 "sslRootCert" | "ssl_root_cert" => Ok(GeneratedField::SslRootCert),
6354 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6355 }
6356 }
6357 }
6358 deserializer.deserialize_identifier(GeneratedVisitor)
6359 }
6360 }
6361 struct GeneratedVisitor;
6362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6363 type Value = PostgresQueryNode;
6364
6365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6366 formatter.write_str("struct batch_plan.PostgresQueryNode")
6367 }
6368
6369 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PostgresQueryNode, V::Error>
6370 where
6371 V: serde::de::MapAccess<'de>,
6372 {
6373 let mut columns__ = None;
6374 let mut hostname__ = None;
6375 let mut port__ = None;
6376 let mut username__ = None;
6377 let mut password__ = None;
6378 let mut database__ = None;
6379 let mut query__ = None;
6380 let mut ssl_mode__ = None;
6381 let mut ssl_root_cert__ = None;
6382 while let Some(k) = map_.next_key()? {
6383 match k {
6384 GeneratedField::Columns => {
6385 if columns__.is_some() {
6386 return Err(serde::de::Error::duplicate_field("columns"));
6387 }
6388 columns__ = Some(map_.next_value()?);
6389 }
6390 GeneratedField::Hostname => {
6391 if hostname__.is_some() {
6392 return Err(serde::de::Error::duplicate_field("hostname"));
6393 }
6394 hostname__ = Some(map_.next_value()?);
6395 }
6396 GeneratedField::Port => {
6397 if port__.is_some() {
6398 return Err(serde::de::Error::duplicate_field("port"));
6399 }
6400 port__ = Some(map_.next_value()?);
6401 }
6402 GeneratedField::Username => {
6403 if username__.is_some() {
6404 return Err(serde::de::Error::duplicate_field("username"));
6405 }
6406 username__ = Some(map_.next_value()?);
6407 }
6408 GeneratedField::Password => {
6409 if password__.is_some() {
6410 return Err(serde::de::Error::duplicate_field("password"));
6411 }
6412 password__ = Some(map_.next_value()?);
6413 }
6414 GeneratedField::Database => {
6415 if database__.is_some() {
6416 return Err(serde::de::Error::duplicate_field("database"));
6417 }
6418 database__ = Some(map_.next_value()?);
6419 }
6420 GeneratedField::Query => {
6421 if query__.is_some() {
6422 return Err(serde::de::Error::duplicate_field("query"));
6423 }
6424 query__ = Some(map_.next_value()?);
6425 }
6426 GeneratedField::SslMode => {
6427 if ssl_mode__.is_some() {
6428 return Err(serde::de::Error::duplicate_field("sslMode"));
6429 }
6430 ssl_mode__ = Some(map_.next_value()?);
6431 }
6432 GeneratedField::SslRootCert => {
6433 if ssl_root_cert__.is_some() {
6434 return Err(serde::de::Error::duplicate_field("sslRootCert"));
6435 }
6436 ssl_root_cert__ = Some(map_.next_value()?);
6437 }
6438 }
6439 }
6440 Ok(PostgresQueryNode {
6441 columns: columns__.unwrap_or_default(),
6442 hostname: hostname__.unwrap_or_default(),
6443 port: port__.unwrap_or_default(),
6444 username: username__.unwrap_or_default(),
6445 password: password__.unwrap_or_default(),
6446 database: database__.unwrap_or_default(),
6447 query: query__.unwrap_or_default(),
6448 ssl_mode: ssl_mode__.unwrap_or_default(),
6449 ssl_root_cert: ssl_root_cert__.unwrap_or_default(),
6450 })
6451 }
6452 }
6453 deserializer.deserialize_struct("batch_plan.PostgresQueryNode", FIELDS, GeneratedVisitor)
6454 }
6455}
6456impl serde::Serialize for ProjectNode {
6457 #[allow(deprecated)]
6458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6459 where
6460 S: serde::Serializer,
6461 {
6462 use serde::ser::SerializeStruct;
6463 let mut len = 0;
6464 if !self.select_list.is_empty() {
6465 len += 1;
6466 }
6467 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectNode", len)?;
6468 if !self.select_list.is_empty() {
6469 struct_ser.serialize_field("selectList", &self.select_list)?;
6470 }
6471 struct_ser.end()
6472 }
6473}
6474impl<'de> serde::Deserialize<'de> for ProjectNode {
6475 #[allow(deprecated)]
6476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6477 where
6478 D: serde::Deserializer<'de>,
6479 {
6480 const FIELDS: &[&str] = &[
6481 "select_list",
6482 "selectList",
6483 ];
6484
6485 #[allow(clippy::enum_variant_names)]
6486 enum GeneratedField {
6487 SelectList,
6488 }
6489 impl<'de> serde::Deserialize<'de> for GeneratedField {
6490 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6491 where
6492 D: serde::Deserializer<'de>,
6493 {
6494 struct GeneratedVisitor;
6495
6496 impl serde::de::Visitor<'_> for GeneratedVisitor {
6497 type Value = GeneratedField;
6498
6499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6500 write!(formatter, "expected one of: {:?}", &FIELDS)
6501 }
6502
6503 #[allow(unused_variables)]
6504 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6505 where
6506 E: serde::de::Error,
6507 {
6508 match value {
6509 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
6510 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6511 }
6512 }
6513 }
6514 deserializer.deserialize_identifier(GeneratedVisitor)
6515 }
6516 }
6517 struct GeneratedVisitor;
6518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6519 type Value = ProjectNode;
6520
6521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6522 formatter.write_str("struct batch_plan.ProjectNode")
6523 }
6524
6525 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
6526 where
6527 V: serde::de::MapAccess<'de>,
6528 {
6529 let mut select_list__ = None;
6530 while let Some(k) = map_.next_key()? {
6531 match k {
6532 GeneratedField::SelectList => {
6533 if select_list__.is_some() {
6534 return Err(serde::de::Error::duplicate_field("selectList"));
6535 }
6536 select_list__ = Some(map_.next_value()?);
6537 }
6538 }
6539 }
6540 Ok(ProjectNode {
6541 select_list: select_list__.unwrap_or_default(),
6542 })
6543 }
6544 }
6545 deserializer.deserialize_struct("batch_plan.ProjectNode", FIELDS, GeneratedVisitor)
6546 }
6547}
6548impl serde::Serialize for ProjectSetNode {
6549 #[allow(deprecated)]
6550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6551 where
6552 S: serde::Serializer,
6553 {
6554 use serde::ser::SerializeStruct;
6555 let mut len = 0;
6556 if !self.select_list.is_empty() {
6557 len += 1;
6558 }
6559 let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectSetNode", len)?;
6560 if !self.select_list.is_empty() {
6561 struct_ser.serialize_field("selectList", &self.select_list)?;
6562 }
6563 struct_ser.end()
6564 }
6565}
6566impl<'de> serde::Deserialize<'de> for ProjectSetNode {
6567 #[allow(deprecated)]
6568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6569 where
6570 D: serde::Deserializer<'de>,
6571 {
6572 const FIELDS: &[&str] = &[
6573 "select_list",
6574 "selectList",
6575 ];
6576
6577 #[allow(clippy::enum_variant_names)]
6578 enum GeneratedField {
6579 SelectList,
6580 }
6581 impl<'de> serde::Deserialize<'de> for GeneratedField {
6582 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6583 where
6584 D: serde::Deserializer<'de>,
6585 {
6586 struct GeneratedVisitor;
6587
6588 impl serde::de::Visitor<'_> for GeneratedVisitor {
6589 type Value = GeneratedField;
6590
6591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6592 write!(formatter, "expected one of: {:?}", &FIELDS)
6593 }
6594
6595 #[allow(unused_variables)]
6596 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6597 where
6598 E: serde::de::Error,
6599 {
6600 match value {
6601 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
6602 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6603 }
6604 }
6605 }
6606 deserializer.deserialize_identifier(GeneratedVisitor)
6607 }
6608 }
6609 struct GeneratedVisitor;
6610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6611 type Value = ProjectSetNode;
6612
6613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6614 formatter.write_str("struct batch_plan.ProjectSetNode")
6615 }
6616
6617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
6618 where
6619 V: serde::de::MapAccess<'de>,
6620 {
6621 let mut select_list__ = None;
6622 while let Some(k) = map_.next_key()? {
6623 match k {
6624 GeneratedField::SelectList => {
6625 if select_list__.is_some() {
6626 return Err(serde::de::Error::duplicate_field("selectList"));
6627 }
6628 select_list__ = Some(map_.next_value()?);
6629 }
6630 }
6631 }
6632 Ok(ProjectSetNode {
6633 select_list: select_list__.unwrap_or_default(),
6634 })
6635 }
6636 }
6637 deserializer.deserialize_struct("batch_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
6638 }
6639}
6640impl serde::Serialize for RowSeqScanNode {
6641 #[allow(deprecated)]
6642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6643 where
6644 S: serde::Serializer,
6645 {
6646 use serde::ser::SerializeStruct;
6647 let mut len = 0;
6648 if self.table_desc.is_some() {
6649 len += 1;
6650 }
6651 if !self.column_ids.is_empty() {
6652 len += 1;
6653 }
6654 if !self.scan_ranges.is_empty() {
6655 len += 1;
6656 }
6657 if self.vnode_bitmap.is_some() {
6658 len += 1;
6659 }
6660 if self.ordered {
6661 len += 1;
6662 }
6663 if self.limit.is_some() {
6664 len += 1;
6665 }
6666 if self.query_epoch.is_some() {
6667 len += 1;
6668 }
6669 let mut struct_ser = serializer.serialize_struct("batch_plan.RowSeqScanNode", len)?;
6670 if let Some(v) = self.table_desc.as_ref() {
6671 struct_ser.serialize_field("tableDesc", v)?;
6672 }
6673 if !self.column_ids.is_empty() {
6674 struct_ser.serialize_field("columnIds", &self.column_ids)?;
6675 }
6676 if !self.scan_ranges.is_empty() {
6677 struct_ser.serialize_field("scanRanges", &self.scan_ranges)?;
6678 }
6679 if let Some(v) = self.vnode_bitmap.as_ref() {
6680 struct_ser.serialize_field("vnodeBitmap", v)?;
6681 }
6682 if self.ordered {
6683 struct_ser.serialize_field("ordered", &self.ordered)?;
6684 }
6685 if let Some(v) = self.limit.as_ref() {
6686 #[allow(clippy::needless_borrow)]
6687 #[allow(clippy::needless_borrows_for_generic_args)]
6688 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
6689 }
6690 if let Some(v) = self.query_epoch.as_ref() {
6691 struct_ser.serialize_field("queryEpoch", v)?;
6692 }
6693 struct_ser.end()
6694 }
6695}
6696impl<'de> serde::Deserialize<'de> for RowSeqScanNode {
6697 #[allow(deprecated)]
6698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6699 where
6700 D: serde::Deserializer<'de>,
6701 {
6702 const FIELDS: &[&str] = &[
6703 "table_desc",
6704 "tableDesc",
6705 "column_ids",
6706 "columnIds",
6707 "scan_ranges",
6708 "scanRanges",
6709 "vnode_bitmap",
6710 "vnodeBitmap",
6711 "ordered",
6712 "limit",
6713 "query_epoch",
6714 "queryEpoch",
6715 ];
6716
6717 #[allow(clippy::enum_variant_names)]
6718 enum GeneratedField {
6719 TableDesc,
6720 ColumnIds,
6721 ScanRanges,
6722 VnodeBitmap,
6723 Ordered,
6724 Limit,
6725 QueryEpoch,
6726 }
6727 impl<'de> serde::Deserialize<'de> for GeneratedField {
6728 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6729 where
6730 D: serde::Deserializer<'de>,
6731 {
6732 struct GeneratedVisitor;
6733
6734 impl serde::de::Visitor<'_> for GeneratedVisitor {
6735 type Value = GeneratedField;
6736
6737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6738 write!(formatter, "expected one of: {:?}", &FIELDS)
6739 }
6740
6741 #[allow(unused_variables)]
6742 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6743 where
6744 E: serde::de::Error,
6745 {
6746 match value {
6747 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
6748 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
6749 "scanRanges" | "scan_ranges" => Ok(GeneratedField::ScanRanges),
6750 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
6751 "ordered" => Ok(GeneratedField::Ordered),
6752 "limit" => Ok(GeneratedField::Limit),
6753 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
6754 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6755 }
6756 }
6757 }
6758 deserializer.deserialize_identifier(GeneratedVisitor)
6759 }
6760 }
6761 struct GeneratedVisitor;
6762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6763 type Value = RowSeqScanNode;
6764
6765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6766 formatter.write_str("struct batch_plan.RowSeqScanNode")
6767 }
6768
6769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowSeqScanNode, V::Error>
6770 where
6771 V: serde::de::MapAccess<'de>,
6772 {
6773 let mut table_desc__ = None;
6774 let mut column_ids__ = None;
6775 let mut scan_ranges__ = None;
6776 let mut vnode_bitmap__ = None;
6777 let mut ordered__ = None;
6778 let mut limit__ = None;
6779 let mut query_epoch__ = None;
6780 while let Some(k) = map_.next_key()? {
6781 match k {
6782 GeneratedField::TableDesc => {
6783 if table_desc__.is_some() {
6784 return Err(serde::de::Error::duplicate_field("tableDesc"));
6785 }
6786 table_desc__ = map_.next_value()?;
6787 }
6788 GeneratedField::ColumnIds => {
6789 if column_ids__.is_some() {
6790 return Err(serde::de::Error::duplicate_field("columnIds"));
6791 }
6792 column_ids__ =
6793 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6794 .into_iter().map(|x| x.0).collect())
6795 ;
6796 }
6797 GeneratedField::ScanRanges => {
6798 if scan_ranges__.is_some() {
6799 return Err(serde::de::Error::duplicate_field("scanRanges"));
6800 }
6801 scan_ranges__ = Some(map_.next_value()?);
6802 }
6803 GeneratedField::VnodeBitmap => {
6804 if vnode_bitmap__.is_some() {
6805 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
6806 }
6807 vnode_bitmap__ = map_.next_value()?;
6808 }
6809 GeneratedField::Ordered => {
6810 if ordered__.is_some() {
6811 return Err(serde::de::Error::duplicate_field("ordered"));
6812 }
6813 ordered__ = Some(map_.next_value()?);
6814 }
6815 GeneratedField::Limit => {
6816 if limit__.is_some() {
6817 return Err(serde::de::Error::duplicate_field("limit"));
6818 }
6819 limit__ =
6820 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6821 ;
6822 }
6823 GeneratedField::QueryEpoch => {
6824 if query_epoch__.is_some() {
6825 return Err(serde::de::Error::duplicate_field("queryEpoch"));
6826 }
6827 query_epoch__ = map_.next_value()?;
6828 }
6829 }
6830 }
6831 Ok(RowSeqScanNode {
6832 table_desc: table_desc__,
6833 column_ids: column_ids__.unwrap_or_default(),
6834 scan_ranges: scan_ranges__.unwrap_or_default(),
6835 vnode_bitmap: vnode_bitmap__,
6836 ordered: ordered__.unwrap_or_default(),
6837 limit: limit__,
6838 query_epoch: query_epoch__,
6839 })
6840 }
6841 }
6842 deserializer.deserialize_struct("batch_plan.RowSeqScanNode", FIELDS, GeneratedVisitor)
6843 }
6844}
6845impl serde::Serialize for ScanRange {
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.eq_conds.is_empty() {
6854 len += 1;
6855 }
6856 if self.lower_bound.is_some() {
6857 len += 1;
6858 }
6859 if self.upper_bound.is_some() {
6860 len += 1;
6861 }
6862 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange", len)?;
6863 if !self.eq_conds.is_empty() {
6864 struct_ser.serialize_field("eqConds", &self.eq_conds.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6865 }
6866 if let Some(v) = self.lower_bound.as_ref() {
6867 struct_ser.serialize_field("lowerBound", v)?;
6868 }
6869 if let Some(v) = self.upper_bound.as_ref() {
6870 struct_ser.serialize_field("upperBound", v)?;
6871 }
6872 struct_ser.end()
6873 }
6874}
6875impl<'de> serde::Deserialize<'de> for ScanRange {
6876 #[allow(deprecated)]
6877 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6878 where
6879 D: serde::Deserializer<'de>,
6880 {
6881 const FIELDS: &[&str] = &[
6882 "eq_conds",
6883 "eqConds",
6884 "lower_bound",
6885 "lowerBound",
6886 "upper_bound",
6887 "upperBound",
6888 ];
6889
6890 #[allow(clippy::enum_variant_names)]
6891 enum GeneratedField {
6892 EqConds,
6893 LowerBound,
6894 UpperBound,
6895 }
6896 impl<'de> serde::Deserialize<'de> for GeneratedField {
6897 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6898 where
6899 D: serde::Deserializer<'de>,
6900 {
6901 struct GeneratedVisitor;
6902
6903 impl serde::de::Visitor<'_> for GeneratedVisitor {
6904 type Value = GeneratedField;
6905
6906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6907 write!(formatter, "expected one of: {:?}", &FIELDS)
6908 }
6909
6910 #[allow(unused_variables)]
6911 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6912 where
6913 E: serde::de::Error,
6914 {
6915 match value {
6916 "eqConds" | "eq_conds" => Ok(GeneratedField::EqConds),
6917 "lowerBound" | "lower_bound" => Ok(GeneratedField::LowerBound),
6918 "upperBound" | "upper_bound" => Ok(GeneratedField::UpperBound),
6919 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6920 }
6921 }
6922 }
6923 deserializer.deserialize_identifier(GeneratedVisitor)
6924 }
6925 }
6926 struct GeneratedVisitor;
6927 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6928 type Value = ScanRange;
6929
6930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6931 formatter.write_str("struct batch_plan.ScanRange")
6932 }
6933
6934 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScanRange, V::Error>
6935 where
6936 V: serde::de::MapAccess<'de>,
6937 {
6938 let mut eq_conds__ = None;
6939 let mut lower_bound__ = None;
6940 let mut upper_bound__ = None;
6941 while let Some(k) = map_.next_key()? {
6942 match k {
6943 GeneratedField::EqConds => {
6944 if eq_conds__.is_some() {
6945 return Err(serde::de::Error::duplicate_field("eqConds"));
6946 }
6947 eq_conds__ =
6948 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6949 .into_iter().map(|x| x.0).collect())
6950 ;
6951 }
6952 GeneratedField::LowerBound => {
6953 if lower_bound__.is_some() {
6954 return Err(serde::de::Error::duplicate_field("lowerBound"));
6955 }
6956 lower_bound__ = map_.next_value()?;
6957 }
6958 GeneratedField::UpperBound => {
6959 if upper_bound__.is_some() {
6960 return Err(serde::de::Error::duplicate_field("upperBound"));
6961 }
6962 upper_bound__ = map_.next_value()?;
6963 }
6964 }
6965 }
6966 Ok(ScanRange {
6967 eq_conds: eq_conds__.unwrap_or_default(),
6968 lower_bound: lower_bound__,
6969 upper_bound: upper_bound__,
6970 })
6971 }
6972 }
6973 deserializer.deserialize_struct("batch_plan.ScanRange", FIELDS, GeneratedVisitor)
6974 }
6975}
6976impl serde::Serialize for scan_range::Bound {
6977 #[allow(deprecated)]
6978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6979 where
6980 S: serde::Serializer,
6981 {
6982 use serde::ser::SerializeStruct;
6983 let mut len = 0;
6984 if !self.value.is_empty() {
6985 len += 1;
6986 }
6987 if self.inclusive {
6988 len += 1;
6989 }
6990 let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange.Bound", len)?;
6991 if !self.value.is_empty() {
6992 struct_ser.serialize_field("value", &self.value.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6993 }
6994 if self.inclusive {
6995 struct_ser.serialize_field("inclusive", &self.inclusive)?;
6996 }
6997 struct_ser.end()
6998 }
6999}
7000impl<'de> serde::Deserialize<'de> for scan_range::Bound {
7001 #[allow(deprecated)]
7002 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7003 where
7004 D: serde::Deserializer<'de>,
7005 {
7006 const FIELDS: &[&str] = &[
7007 "value",
7008 "inclusive",
7009 ];
7010
7011 #[allow(clippy::enum_variant_names)]
7012 enum GeneratedField {
7013 Value,
7014 Inclusive,
7015 }
7016 impl<'de> serde::Deserialize<'de> for GeneratedField {
7017 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7018 where
7019 D: serde::Deserializer<'de>,
7020 {
7021 struct GeneratedVisitor;
7022
7023 impl serde::de::Visitor<'_> for GeneratedVisitor {
7024 type Value = GeneratedField;
7025
7026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7027 write!(formatter, "expected one of: {:?}", &FIELDS)
7028 }
7029
7030 #[allow(unused_variables)]
7031 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7032 where
7033 E: serde::de::Error,
7034 {
7035 match value {
7036 "value" => Ok(GeneratedField::Value),
7037 "inclusive" => Ok(GeneratedField::Inclusive),
7038 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7039 }
7040 }
7041 }
7042 deserializer.deserialize_identifier(GeneratedVisitor)
7043 }
7044 }
7045 struct GeneratedVisitor;
7046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7047 type Value = scan_range::Bound;
7048
7049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7050 formatter.write_str("struct batch_plan.ScanRange.Bound")
7051 }
7052
7053 fn visit_map<V>(self, mut map_: V) -> std::result::Result<scan_range::Bound, V::Error>
7054 where
7055 V: serde::de::MapAccess<'de>,
7056 {
7057 let mut value__ = None;
7058 let mut inclusive__ = None;
7059 while let Some(k) = map_.next_key()? {
7060 match k {
7061 GeneratedField::Value => {
7062 if value__.is_some() {
7063 return Err(serde::de::Error::duplicate_field("value"));
7064 }
7065 value__ =
7066 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7067 .into_iter().map(|x| x.0).collect())
7068 ;
7069 }
7070 GeneratedField::Inclusive => {
7071 if inclusive__.is_some() {
7072 return Err(serde::de::Error::duplicate_field("inclusive"));
7073 }
7074 inclusive__ = Some(map_.next_value()?);
7075 }
7076 }
7077 }
7078 Ok(scan_range::Bound {
7079 value: value__.unwrap_or_default(),
7080 inclusive: inclusive__.unwrap_or_default(),
7081 })
7082 }
7083 }
7084 deserializer.deserialize_struct("batch_plan.ScanRange.Bound", FIELDS, GeneratedVisitor)
7085 }
7086}
7087impl serde::Serialize for SortAggNode {
7088 #[allow(deprecated)]
7089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7090 where
7091 S: serde::Serializer,
7092 {
7093 use serde::ser::SerializeStruct;
7094 let mut len = 0;
7095 if !self.group_key.is_empty() {
7096 len += 1;
7097 }
7098 if !self.agg_calls.is_empty() {
7099 len += 1;
7100 }
7101 let mut struct_ser = serializer.serialize_struct("batch_plan.SortAggNode", len)?;
7102 if !self.group_key.is_empty() {
7103 struct_ser.serialize_field("groupKey", &self.group_key)?;
7104 }
7105 if !self.agg_calls.is_empty() {
7106 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
7107 }
7108 struct_ser.end()
7109 }
7110}
7111impl<'de> serde::Deserialize<'de> for SortAggNode {
7112 #[allow(deprecated)]
7113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7114 where
7115 D: serde::Deserializer<'de>,
7116 {
7117 const FIELDS: &[&str] = &[
7118 "group_key",
7119 "groupKey",
7120 "agg_calls",
7121 "aggCalls",
7122 ];
7123
7124 #[allow(clippy::enum_variant_names)]
7125 enum GeneratedField {
7126 GroupKey,
7127 AggCalls,
7128 }
7129 impl<'de> serde::Deserialize<'de> for GeneratedField {
7130 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7131 where
7132 D: serde::Deserializer<'de>,
7133 {
7134 struct GeneratedVisitor;
7135
7136 impl serde::de::Visitor<'_> for GeneratedVisitor {
7137 type Value = GeneratedField;
7138
7139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7140 write!(formatter, "expected one of: {:?}", &FIELDS)
7141 }
7142
7143 #[allow(unused_variables)]
7144 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7145 where
7146 E: serde::de::Error,
7147 {
7148 match value {
7149 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
7150 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
7151 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7152 }
7153 }
7154 }
7155 deserializer.deserialize_identifier(GeneratedVisitor)
7156 }
7157 }
7158 struct GeneratedVisitor;
7159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7160 type Value = SortAggNode;
7161
7162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7163 formatter.write_str("struct batch_plan.SortAggNode")
7164 }
7165
7166 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortAggNode, V::Error>
7167 where
7168 V: serde::de::MapAccess<'de>,
7169 {
7170 let mut group_key__ = None;
7171 let mut agg_calls__ = None;
7172 while let Some(k) = map_.next_key()? {
7173 match k {
7174 GeneratedField::GroupKey => {
7175 if group_key__.is_some() {
7176 return Err(serde::de::Error::duplicate_field("groupKey"));
7177 }
7178 group_key__ = Some(map_.next_value()?);
7179 }
7180 GeneratedField::AggCalls => {
7181 if agg_calls__.is_some() {
7182 return Err(serde::de::Error::duplicate_field("aggCalls"));
7183 }
7184 agg_calls__ = Some(map_.next_value()?);
7185 }
7186 }
7187 }
7188 Ok(SortAggNode {
7189 group_key: group_key__.unwrap_or_default(),
7190 agg_calls: agg_calls__.unwrap_or_default(),
7191 })
7192 }
7193 }
7194 deserializer.deserialize_struct("batch_plan.SortAggNode", FIELDS, GeneratedVisitor)
7195 }
7196}
7197impl serde::Serialize for SortMergeJoinNode {
7198 #[allow(deprecated)]
7199 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7200 where
7201 S: serde::Serializer,
7202 {
7203 use serde::ser::SerializeStruct;
7204 let mut len = 0;
7205 if self.join_type != 0 {
7206 len += 1;
7207 }
7208 if !self.left_key.is_empty() {
7209 len += 1;
7210 }
7211 if !self.right_key.is_empty() {
7212 len += 1;
7213 }
7214 if self.direction != 0 {
7215 len += 1;
7216 }
7217 if !self.output_indices.is_empty() {
7218 len += 1;
7219 }
7220 let mut struct_ser = serializer.serialize_struct("batch_plan.SortMergeJoinNode", len)?;
7221 if self.join_type != 0 {
7222 let v = super::plan_common::JoinType::try_from(self.join_type)
7223 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
7224 struct_ser.serialize_field("joinType", &v)?;
7225 }
7226 if !self.left_key.is_empty() {
7227 struct_ser.serialize_field("leftKey", &self.left_key)?;
7228 }
7229 if !self.right_key.is_empty() {
7230 struct_ser.serialize_field("rightKey", &self.right_key)?;
7231 }
7232 if self.direction != 0 {
7233 let v = super::common::Direction::try_from(self.direction)
7234 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
7235 struct_ser.serialize_field("direction", &v)?;
7236 }
7237 if !self.output_indices.is_empty() {
7238 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
7239 }
7240 struct_ser.end()
7241 }
7242}
7243impl<'de> serde::Deserialize<'de> for SortMergeJoinNode {
7244 #[allow(deprecated)]
7245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7246 where
7247 D: serde::Deserializer<'de>,
7248 {
7249 const FIELDS: &[&str] = &[
7250 "join_type",
7251 "joinType",
7252 "left_key",
7253 "leftKey",
7254 "right_key",
7255 "rightKey",
7256 "direction",
7257 "output_indices",
7258 "outputIndices",
7259 ];
7260
7261 #[allow(clippy::enum_variant_names)]
7262 enum GeneratedField {
7263 JoinType,
7264 LeftKey,
7265 RightKey,
7266 Direction,
7267 OutputIndices,
7268 }
7269 impl<'de> serde::Deserialize<'de> for GeneratedField {
7270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7271 where
7272 D: serde::Deserializer<'de>,
7273 {
7274 struct GeneratedVisitor;
7275
7276 impl serde::de::Visitor<'_> for GeneratedVisitor {
7277 type Value = GeneratedField;
7278
7279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7280 write!(formatter, "expected one of: {:?}", &FIELDS)
7281 }
7282
7283 #[allow(unused_variables)]
7284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7285 where
7286 E: serde::de::Error,
7287 {
7288 match value {
7289 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
7290 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
7291 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
7292 "direction" => Ok(GeneratedField::Direction),
7293 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
7294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7295 }
7296 }
7297 }
7298 deserializer.deserialize_identifier(GeneratedVisitor)
7299 }
7300 }
7301 struct GeneratedVisitor;
7302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7303 type Value = SortMergeJoinNode;
7304
7305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7306 formatter.write_str("struct batch_plan.SortMergeJoinNode")
7307 }
7308
7309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortMergeJoinNode, V::Error>
7310 where
7311 V: serde::de::MapAccess<'de>,
7312 {
7313 let mut join_type__ = None;
7314 let mut left_key__ = None;
7315 let mut right_key__ = None;
7316 let mut direction__ = None;
7317 let mut output_indices__ = None;
7318 while let Some(k) = map_.next_key()? {
7319 match k {
7320 GeneratedField::JoinType => {
7321 if join_type__.is_some() {
7322 return Err(serde::de::Error::duplicate_field("joinType"));
7323 }
7324 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
7325 }
7326 GeneratedField::LeftKey => {
7327 if left_key__.is_some() {
7328 return Err(serde::de::Error::duplicate_field("leftKey"));
7329 }
7330 left_key__ =
7331 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7332 .into_iter().map(|x| x.0).collect())
7333 ;
7334 }
7335 GeneratedField::RightKey => {
7336 if right_key__.is_some() {
7337 return Err(serde::de::Error::duplicate_field("rightKey"));
7338 }
7339 right_key__ =
7340 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7341 .into_iter().map(|x| x.0).collect())
7342 ;
7343 }
7344 GeneratedField::Direction => {
7345 if direction__.is_some() {
7346 return Err(serde::de::Error::duplicate_field("direction"));
7347 }
7348 direction__ = Some(map_.next_value::<super::common::Direction>()? as i32);
7349 }
7350 GeneratedField::OutputIndices => {
7351 if output_indices__.is_some() {
7352 return Err(serde::de::Error::duplicate_field("outputIndices"));
7353 }
7354 output_indices__ =
7355 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7356 .into_iter().map(|x| x.0).collect())
7357 ;
7358 }
7359 }
7360 }
7361 Ok(SortMergeJoinNode {
7362 join_type: join_type__.unwrap_or_default(),
7363 left_key: left_key__.unwrap_or_default(),
7364 right_key: right_key__.unwrap_or_default(),
7365 direction: direction__.unwrap_or_default(),
7366 output_indices: output_indices__.unwrap_or_default(),
7367 })
7368 }
7369 }
7370 deserializer.deserialize_struct("batch_plan.SortMergeJoinNode", FIELDS, GeneratedVisitor)
7371 }
7372}
7373impl serde::Serialize for SortNode {
7374 #[allow(deprecated)]
7375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7376 where
7377 S: serde::Serializer,
7378 {
7379 use serde::ser::SerializeStruct;
7380 let mut len = 0;
7381 if !self.column_orders.is_empty() {
7382 len += 1;
7383 }
7384 let mut struct_ser = serializer.serialize_struct("batch_plan.SortNode", len)?;
7385 if !self.column_orders.is_empty() {
7386 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7387 }
7388 struct_ser.end()
7389 }
7390}
7391impl<'de> serde::Deserialize<'de> for SortNode {
7392 #[allow(deprecated)]
7393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7394 where
7395 D: serde::Deserializer<'de>,
7396 {
7397 const FIELDS: &[&str] = &[
7398 "column_orders",
7399 "columnOrders",
7400 ];
7401
7402 #[allow(clippy::enum_variant_names)]
7403 enum GeneratedField {
7404 ColumnOrders,
7405 }
7406 impl<'de> serde::Deserialize<'de> for GeneratedField {
7407 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7408 where
7409 D: serde::Deserializer<'de>,
7410 {
7411 struct GeneratedVisitor;
7412
7413 impl serde::de::Visitor<'_> for GeneratedVisitor {
7414 type Value = GeneratedField;
7415
7416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7417 write!(formatter, "expected one of: {:?}", &FIELDS)
7418 }
7419
7420 #[allow(unused_variables)]
7421 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7422 where
7423 E: serde::de::Error,
7424 {
7425 match value {
7426 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7427 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7428 }
7429 }
7430 }
7431 deserializer.deserialize_identifier(GeneratedVisitor)
7432 }
7433 }
7434 struct GeneratedVisitor;
7435 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7436 type Value = SortNode;
7437
7438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7439 formatter.write_str("struct batch_plan.SortNode")
7440 }
7441
7442 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
7443 where
7444 V: serde::de::MapAccess<'de>,
7445 {
7446 let mut column_orders__ = None;
7447 while let Some(k) = map_.next_key()? {
7448 match k {
7449 GeneratedField::ColumnOrders => {
7450 if column_orders__.is_some() {
7451 return Err(serde::de::Error::duplicate_field("columnOrders"));
7452 }
7453 column_orders__ = Some(map_.next_value()?);
7454 }
7455 }
7456 }
7457 Ok(SortNode {
7458 column_orders: column_orders__.unwrap_or_default(),
7459 })
7460 }
7461 }
7462 deserializer.deserialize_struct("batch_plan.SortNode", FIELDS, GeneratedVisitor)
7463 }
7464}
7465impl serde::Serialize for SortOverWindowNode {
7466 #[allow(deprecated)]
7467 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7468 where
7469 S: serde::Serializer,
7470 {
7471 use serde::ser::SerializeStruct;
7472 let mut len = 0;
7473 if !self.calls.is_empty() {
7474 len += 1;
7475 }
7476 if !self.partition_by.is_empty() {
7477 len += 1;
7478 }
7479 if !self.order_by.is_empty() {
7480 len += 1;
7481 }
7482 let mut struct_ser = serializer.serialize_struct("batch_plan.SortOverWindowNode", len)?;
7483 if !self.calls.is_empty() {
7484 struct_ser.serialize_field("calls", &self.calls)?;
7485 }
7486 if !self.partition_by.is_empty() {
7487 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7488 }
7489 if !self.order_by.is_empty() {
7490 struct_ser.serialize_field("orderBy", &self.order_by)?;
7491 }
7492 struct_ser.end()
7493 }
7494}
7495impl<'de> serde::Deserialize<'de> for SortOverWindowNode {
7496 #[allow(deprecated)]
7497 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7498 where
7499 D: serde::Deserializer<'de>,
7500 {
7501 const FIELDS: &[&str] = &[
7502 "calls",
7503 "partition_by",
7504 "partitionBy",
7505 "order_by",
7506 "orderBy",
7507 ];
7508
7509 #[allow(clippy::enum_variant_names)]
7510 enum GeneratedField {
7511 Calls,
7512 PartitionBy,
7513 OrderBy,
7514 }
7515 impl<'de> serde::Deserialize<'de> for GeneratedField {
7516 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7517 where
7518 D: serde::Deserializer<'de>,
7519 {
7520 struct GeneratedVisitor;
7521
7522 impl serde::de::Visitor<'_> for GeneratedVisitor {
7523 type Value = GeneratedField;
7524
7525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7526 write!(formatter, "expected one of: {:?}", &FIELDS)
7527 }
7528
7529 #[allow(unused_variables)]
7530 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7531 where
7532 E: serde::de::Error,
7533 {
7534 match value {
7535 "calls" => Ok(GeneratedField::Calls),
7536 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7537 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7538 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7539 }
7540 }
7541 }
7542 deserializer.deserialize_identifier(GeneratedVisitor)
7543 }
7544 }
7545 struct GeneratedVisitor;
7546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7547 type Value = SortOverWindowNode;
7548
7549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7550 formatter.write_str("struct batch_plan.SortOverWindowNode")
7551 }
7552
7553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortOverWindowNode, V::Error>
7554 where
7555 V: serde::de::MapAccess<'de>,
7556 {
7557 let mut calls__ = None;
7558 let mut partition_by__ = None;
7559 let mut order_by__ = None;
7560 while let Some(k) = map_.next_key()? {
7561 match k {
7562 GeneratedField::Calls => {
7563 if calls__.is_some() {
7564 return Err(serde::de::Error::duplicate_field("calls"));
7565 }
7566 calls__ = Some(map_.next_value()?);
7567 }
7568 GeneratedField::PartitionBy => {
7569 if partition_by__.is_some() {
7570 return Err(serde::de::Error::duplicate_field("partitionBy"));
7571 }
7572 partition_by__ =
7573 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7574 .into_iter().map(|x| x.0).collect())
7575 ;
7576 }
7577 GeneratedField::OrderBy => {
7578 if order_by__.is_some() {
7579 return Err(serde::de::Error::duplicate_field("orderBy"));
7580 }
7581 order_by__ = Some(map_.next_value()?);
7582 }
7583 }
7584 }
7585 Ok(SortOverWindowNode {
7586 calls: calls__.unwrap_or_default(),
7587 partition_by: partition_by__.unwrap_or_default(),
7588 order_by: order_by__.unwrap_or_default(),
7589 })
7590 }
7591 }
7592 deserializer.deserialize_struct("batch_plan.SortOverWindowNode", FIELDS, GeneratedVisitor)
7593 }
7594}
7595impl serde::Serialize for SourceNode {
7596 #[allow(deprecated)]
7597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7598 where
7599 S: serde::Serializer,
7600 {
7601 use serde::ser::SerializeStruct;
7602 let mut len = 0;
7603 if self.source_id != 0 {
7604 len += 1;
7605 }
7606 if !self.columns.is_empty() {
7607 len += 1;
7608 }
7609 if !self.with_properties.is_empty() {
7610 len += 1;
7611 }
7612 if !self.split.is_empty() {
7613 len += 1;
7614 }
7615 if self.info.is_some() {
7616 len += 1;
7617 }
7618 if !self.secret_refs.is_empty() {
7619 len += 1;
7620 }
7621 let mut struct_ser = serializer.serialize_struct("batch_plan.SourceNode", len)?;
7622 if self.source_id != 0 {
7623 struct_ser.serialize_field("sourceId", &self.source_id)?;
7624 }
7625 if !self.columns.is_empty() {
7626 struct_ser.serialize_field("columns", &self.columns)?;
7627 }
7628 if !self.with_properties.is_empty() {
7629 struct_ser.serialize_field("withProperties", &self.with_properties)?;
7630 }
7631 if !self.split.is_empty() {
7632 struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
7633 }
7634 if let Some(v) = self.info.as_ref() {
7635 struct_ser.serialize_field("info", v)?;
7636 }
7637 if !self.secret_refs.is_empty() {
7638 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
7639 }
7640 struct_ser.end()
7641 }
7642}
7643impl<'de> serde::Deserialize<'de> for SourceNode {
7644 #[allow(deprecated)]
7645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7646 where
7647 D: serde::Deserializer<'de>,
7648 {
7649 const FIELDS: &[&str] = &[
7650 "source_id",
7651 "sourceId",
7652 "columns",
7653 "with_properties",
7654 "withProperties",
7655 "split",
7656 "info",
7657 "secret_refs",
7658 "secretRefs",
7659 ];
7660
7661 #[allow(clippy::enum_variant_names)]
7662 enum GeneratedField {
7663 SourceId,
7664 Columns,
7665 WithProperties,
7666 Split,
7667 Info,
7668 SecretRefs,
7669 }
7670 impl<'de> serde::Deserialize<'de> for GeneratedField {
7671 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7672 where
7673 D: serde::Deserializer<'de>,
7674 {
7675 struct GeneratedVisitor;
7676
7677 impl serde::de::Visitor<'_> for GeneratedVisitor {
7678 type Value = GeneratedField;
7679
7680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7681 write!(formatter, "expected one of: {:?}", &FIELDS)
7682 }
7683
7684 #[allow(unused_variables)]
7685 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7686 where
7687 E: serde::de::Error,
7688 {
7689 match value {
7690 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7691 "columns" => Ok(GeneratedField::Columns),
7692 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
7693 "split" => Ok(GeneratedField::Split),
7694 "info" => Ok(GeneratedField::Info),
7695 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
7696 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7697 }
7698 }
7699 }
7700 deserializer.deserialize_identifier(GeneratedVisitor)
7701 }
7702 }
7703 struct GeneratedVisitor;
7704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7705 type Value = SourceNode;
7706
7707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7708 formatter.write_str("struct batch_plan.SourceNode")
7709 }
7710
7711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
7712 where
7713 V: serde::de::MapAccess<'de>,
7714 {
7715 let mut source_id__ = None;
7716 let mut columns__ = None;
7717 let mut with_properties__ = None;
7718 let mut split__ = None;
7719 let mut info__ = None;
7720 let mut secret_refs__ = None;
7721 while let Some(k) = map_.next_key()? {
7722 match k {
7723 GeneratedField::SourceId => {
7724 if source_id__.is_some() {
7725 return Err(serde::de::Error::duplicate_field("sourceId"));
7726 }
7727 source_id__ =
7728 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7729 ;
7730 }
7731 GeneratedField::Columns => {
7732 if columns__.is_some() {
7733 return Err(serde::de::Error::duplicate_field("columns"));
7734 }
7735 columns__ = Some(map_.next_value()?);
7736 }
7737 GeneratedField::WithProperties => {
7738 if with_properties__.is_some() {
7739 return Err(serde::de::Error::duplicate_field("withProperties"));
7740 }
7741 with_properties__ = Some(
7742 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7743 );
7744 }
7745 GeneratedField::Split => {
7746 if split__.is_some() {
7747 return Err(serde::de::Error::duplicate_field("split"));
7748 }
7749 split__ =
7750 Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7751 .into_iter().map(|x| x.0).collect())
7752 ;
7753 }
7754 GeneratedField::Info => {
7755 if info__.is_some() {
7756 return Err(serde::de::Error::duplicate_field("info"));
7757 }
7758 info__ = map_.next_value()?;
7759 }
7760 GeneratedField::SecretRefs => {
7761 if secret_refs__.is_some() {
7762 return Err(serde::de::Error::duplicate_field("secretRefs"));
7763 }
7764 secret_refs__ = Some(
7765 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7766 );
7767 }
7768 }
7769 }
7770 Ok(SourceNode {
7771 source_id: source_id__.unwrap_or_default(),
7772 columns: columns__.unwrap_or_default(),
7773 with_properties: with_properties__.unwrap_or_default(),
7774 split: split__.unwrap_or_default(),
7775 info: info__,
7776 secret_refs: secret_refs__.unwrap_or_default(),
7777 })
7778 }
7779 }
7780 deserializer.deserialize_struct("batch_plan.SourceNode", FIELDS, GeneratedVisitor)
7781 }
7782}
7783impl serde::Serialize for SysRowSeqScanNode {
7784 #[allow(deprecated)]
7785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7786 where
7787 S: serde::Serializer,
7788 {
7789 use serde::ser::SerializeStruct;
7790 let mut len = 0;
7791 if self.table_id != 0 {
7792 len += 1;
7793 }
7794 if !self.column_descs.is_empty() {
7795 len += 1;
7796 }
7797 let mut struct_ser = serializer.serialize_struct("batch_plan.SysRowSeqScanNode", len)?;
7798 if self.table_id != 0 {
7799 struct_ser.serialize_field("tableId", &self.table_id)?;
7800 }
7801 if !self.column_descs.is_empty() {
7802 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
7803 }
7804 struct_ser.end()
7805 }
7806}
7807impl<'de> serde::Deserialize<'de> for SysRowSeqScanNode {
7808 #[allow(deprecated)]
7809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7810 where
7811 D: serde::Deserializer<'de>,
7812 {
7813 const FIELDS: &[&str] = &[
7814 "table_id",
7815 "tableId",
7816 "column_descs",
7817 "columnDescs",
7818 ];
7819
7820 #[allow(clippy::enum_variant_names)]
7821 enum GeneratedField {
7822 TableId,
7823 ColumnDescs,
7824 }
7825 impl<'de> serde::Deserialize<'de> for GeneratedField {
7826 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7827 where
7828 D: serde::Deserializer<'de>,
7829 {
7830 struct GeneratedVisitor;
7831
7832 impl serde::de::Visitor<'_> for GeneratedVisitor {
7833 type Value = GeneratedField;
7834
7835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7836 write!(formatter, "expected one of: {:?}", &FIELDS)
7837 }
7838
7839 #[allow(unused_variables)]
7840 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7841 where
7842 E: serde::de::Error,
7843 {
7844 match value {
7845 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7846 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
7847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7848 }
7849 }
7850 }
7851 deserializer.deserialize_identifier(GeneratedVisitor)
7852 }
7853 }
7854 struct GeneratedVisitor;
7855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7856 type Value = SysRowSeqScanNode;
7857
7858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7859 formatter.write_str("struct batch_plan.SysRowSeqScanNode")
7860 }
7861
7862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SysRowSeqScanNode, V::Error>
7863 where
7864 V: serde::de::MapAccess<'de>,
7865 {
7866 let mut table_id__ = None;
7867 let mut column_descs__ = None;
7868 while let Some(k) = map_.next_key()? {
7869 match k {
7870 GeneratedField::TableId => {
7871 if table_id__.is_some() {
7872 return Err(serde::de::Error::duplicate_field("tableId"));
7873 }
7874 table_id__ =
7875 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7876 ;
7877 }
7878 GeneratedField::ColumnDescs => {
7879 if column_descs__.is_some() {
7880 return Err(serde::de::Error::duplicate_field("columnDescs"));
7881 }
7882 column_descs__ = Some(map_.next_value()?);
7883 }
7884 }
7885 }
7886 Ok(SysRowSeqScanNode {
7887 table_id: table_id__.unwrap_or_default(),
7888 column_descs: column_descs__.unwrap_or_default(),
7889 })
7890 }
7891 }
7892 deserializer.deserialize_struct("batch_plan.SysRowSeqScanNode", FIELDS, GeneratedVisitor)
7893 }
7894}
7895impl serde::Serialize for TableFunctionNode {
7896 #[allow(deprecated)]
7897 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7898 where
7899 S: serde::Serializer,
7900 {
7901 use serde::ser::SerializeStruct;
7902 let mut len = 0;
7903 if self.table_function.is_some() {
7904 len += 1;
7905 }
7906 let mut struct_ser = serializer.serialize_struct("batch_plan.TableFunctionNode", len)?;
7907 if let Some(v) = self.table_function.as_ref() {
7908 struct_ser.serialize_field("tableFunction", v)?;
7909 }
7910 struct_ser.end()
7911 }
7912}
7913impl<'de> serde::Deserialize<'de> for TableFunctionNode {
7914 #[allow(deprecated)]
7915 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7916 where
7917 D: serde::Deserializer<'de>,
7918 {
7919 const FIELDS: &[&str] = &[
7920 "table_function",
7921 "tableFunction",
7922 ];
7923
7924 #[allow(clippy::enum_variant_names)]
7925 enum GeneratedField {
7926 TableFunction,
7927 }
7928 impl<'de> serde::Deserialize<'de> for GeneratedField {
7929 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7930 where
7931 D: serde::Deserializer<'de>,
7932 {
7933 struct GeneratedVisitor;
7934
7935 impl serde::de::Visitor<'_> for GeneratedVisitor {
7936 type Value = GeneratedField;
7937
7938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7939 write!(formatter, "expected one of: {:?}", &FIELDS)
7940 }
7941
7942 #[allow(unused_variables)]
7943 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7944 where
7945 E: serde::de::Error,
7946 {
7947 match value {
7948 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
7949 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7950 }
7951 }
7952 }
7953 deserializer.deserialize_identifier(GeneratedVisitor)
7954 }
7955 }
7956 struct GeneratedVisitor;
7957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7958 type Value = TableFunctionNode;
7959
7960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7961 formatter.write_str("struct batch_plan.TableFunctionNode")
7962 }
7963
7964 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunctionNode, V::Error>
7965 where
7966 V: serde::de::MapAccess<'de>,
7967 {
7968 let mut table_function__ = None;
7969 while let Some(k) = map_.next_key()? {
7970 match k {
7971 GeneratedField::TableFunction => {
7972 if table_function__.is_some() {
7973 return Err(serde::de::Error::duplicate_field("tableFunction"));
7974 }
7975 table_function__ = map_.next_value()?;
7976 }
7977 }
7978 }
7979 Ok(TableFunctionNode {
7980 table_function: table_function__,
7981 })
7982 }
7983 }
7984 deserializer.deserialize_struct("batch_plan.TableFunctionNode", FIELDS, GeneratedVisitor)
7985 }
7986}
7987impl serde::Serialize for TaskId {
7988 #[allow(deprecated)]
7989 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7990 where
7991 S: serde::Serializer,
7992 {
7993 use serde::ser::SerializeStruct;
7994 let mut len = 0;
7995 if !self.query_id.is_empty() {
7996 len += 1;
7997 }
7998 if self.stage_id != 0 {
7999 len += 1;
8000 }
8001 if self.task_id != 0 {
8002 len += 1;
8003 }
8004 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskId", len)?;
8005 if !self.query_id.is_empty() {
8006 struct_ser.serialize_field("queryId", &self.query_id)?;
8007 }
8008 if self.stage_id != 0 {
8009 struct_ser.serialize_field("stageId", &self.stage_id)?;
8010 }
8011 if self.task_id != 0 {
8012 #[allow(clippy::needless_borrow)]
8013 #[allow(clippy::needless_borrows_for_generic_args)]
8014 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
8015 }
8016 struct_ser.end()
8017 }
8018}
8019impl<'de> serde::Deserialize<'de> for TaskId {
8020 #[allow(deprecated)]
8021 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8022 where
8023 D: serde::Deserializer<'de>,
8024 {
8025 const FIELDS: &[&str] = &[
8026 "query_id",
8027 "queryId",
8028 "stage_id",
8029 "stageId",
8030 "task_id",
8031 "taskId",
8032 ];
8033
8034 #[allow(clippy::enum_variant_names)]
8035 enum GeneratedField {
8036 QueryId,
8037 StageId,
8038 TaskId,
8039 }
8040 impl<'de> serde::Deserialize<'de> for GeneratedField {
8041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8042 where
8043 D: serde::Deserializer<'de>,
8044 {
8045 struct GeneratedVisitor;
8046
8047 impl serde::de::Visitor<'_> for GeneratedVisitor {
8048 type Value = GeneratedField;
8049
8050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8051 write!(formatter, "expected one of: {:?}", &FIELDS)
8052 }
8053
8054 #[allow(unused_variables)]
8055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8056 where
8057 E: serde::de::Error,
8058 {
8059 match value {
8060 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
8061 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
8062 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8063 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8064 }
8065 }
8066 }
8067 deserializer.deserialize_identifier(GeneratedVisitor)
8068 }
8069 }
8070 struct GeneratedVisitor;
8071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8072 type Value = TaskId;
8073
8074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8075 formatter.write_str("struct batch_plan.TaskId")
8076 }
8077
8078 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
8079 where
8080 V: serde::de::MapAccess<'de>,
8081 {
8082 let mut query_id__ = None;
8083 let mut stage_id__ = None;
8084 let mut task_id__ = None;
8085 while let Some(k) = map_.next_key()? {
8086 match k {
8087 GeneratedField::QueryId => {
8088 if query_id__.is_some() {
8089 return Err(serde::de::Error::duplicate_field("queryId"));
8090 }
8091 query_id__ = Some(map_.next_value()?);
8092 }
8093 GeneratedField::StageId => {
8094 if stage_id__.is_some() {
8095 return Err(serde::de::Error::duplicate_field("stageId"));
8096 }
8097 stage_id__ =
8098 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8099 ;
8100 }
8101 GeneratedField::TaskId => {
8102 if task_id__.is_some() {
8103 return Err(serde::de::Error::duplicate_field("taskId"));
8104 }
8105 task_id__ =
8106 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8107 ;
8108 }
8109 }
8110 }
8111 Ok(TaskId {
8112 query_id: query_id__.unwrap_or_default(),
8113 stage_id: stage_id__.unwrap_or_default(),
8114 task_id: task_id__.unwrap_or_default(),
8115 })
8116 }
8117 }
8118 deserializer.deserialize_struct("batch_plan.TaskId", FIELDS, GeneratedVisitor)
8119 }
8120}
8121impl serde::Serialize for TaskOutputId {
8122 #[allow(deprecated)]
8123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8124 where
8125 S: serde::Serializer,
8126 {
8127 use serde::ser::SerializeStruct;
8128 let mut len = 0;
8129 if self.task_id.is_some() {
8130 len += 1;
8131 }
8132 if self.output_id != 0 {
8133 len += 1;
8134 }
8135 let mut struct_ser = serializer.serialize_struct("batch_plan.TaskOutputId", len)?;
8136 if let Some(v) = self.task_id.as_ref() {
8137 struct_ser.serialize_field("taskId", v)?;
8138 }
8139 if self.output_id != 0 {
8140 #[allow(clippy::needless_borrow)]
8141 #[allow(clippy::needless_borrows_for_generic_args)]
8142 struct_ser.serialize_field("outputId", ToString::to_string(&self.output_id).as_str())?;
8143 }
8144 struct_ser.end()
8145 }
8146}
8147impl<'de> serde::Deserialize<'de> for TaskOutputId {
8148 #[allow(deprecated)]
8149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8150 where
8151 D: serde::Deserializer<'de>,
8152 {
8153 const FIELDS: &[&str] = &[
8154 "task_id",
8155 "taskId",
8156 "output_id",
8157 "outputId",
8158 ];
8159
8160 #[allow(clippy::enum_variant_names)]
8161 enum GeneratedField {
8162 TaskId,
8163 OutputId,
8164 }
8165 impl<'de> serde::Deserialize<'de> for GeneratedField {
8166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8167 where
8168 D: serde::Deserializer<'de>,
8169 {
8170 struct GeneratedVisitor;
8171
8172 impl serde::de::Visitor<'_> for GeneratedVisitor {
8173 type Value = GeneratedField;
8174
8175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8176 write!(formatter, "expected one of: {:?}", &FIELDS)
8177 }
8178
8179 #[allow(unused_variables)]
8180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8181 where
8182 E: serde::de::Error,
8183 {
8184 match value {
8185 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8186 "outputId" | "output_id" => Ok(GeneratedField::OutputId),
8187 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8188 }
8189 }
8190 }
8191 deserializer.deserialize_identifier(GeneratedVisitor)
8192 }
8193 }
8194 struct GeneratedVisitor;
8195 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8196 type Value = TaskOutputId;
8197
8198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8199 formatter.write_str("struct batch_plan.TaskOutputId")
8200 }
8201
8202 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskOutputId, V::Error>
8203 where
8204 V: serde::de::MapAccess<'de>,
8205 {
8206 let mut task_id__ = None;
8207 let mut output_id__ = None;
8208 while let Some(k) = map_.next_key()? {
8209 match k {
8210 GeneratedField::TaskId => {
8211 if task_id__.is_some() {
8212 return Err(serde::de::Error::duplicate_field("taskId"));
8213 }
8214 task_id__ = map_.next_value()?;
8215 }
8216 GeneratedField::OutputId => {
8217 if output_id__.is_some() {
8218 return Err(serde::de::Error::duplicate_field("outputId"));
8219 }
8220 output_id__ =
8221 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8222 ;
8223 }
8224 }
8225 }
8226 Ok(TaskOutputId {
8227 task_id: task_id__,
8228 output_id: output_id__.unwrap_or_default(),
8229 })
8230 }
8231 }
8232 deserializer.deserialize_struct("batch_plan.TaskOutputId", FIELDS, GeneratedVisitor)
8233 }
8234}
8235impl serde::Serialize for TopNNode {
8236 #[allow(deprecated)]
8237 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8238 where
8239 S: serde::Serializer,
8240 {
8241 use serde::ser::SerializeStruct;
8242 let mut len = 0;
8243 if !self.column_orders.is_empty() {
8244 len += 1;
8245 }
8246 if self.limit != 0 {
8247 len += 1;
8248 }
8249 if self.offset != 0 {
8250 len += 1;
8251 }
8252 if self.with_ties {
8253 len += 1;
8254 }
8255 let mut struct_ser = serializer.serialize_struct("batch_plan.TopNNode", len)?;
8256 if !self.column_orders.is_empty() {
8257 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
8258 }
8259 if self.limit != 0 {
8260 #[allow(clippy::needless_borrow)]
8261 #[allow(clippy::needless_borrows_for_generic_args)]
8262 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
8263 }
8264 if self.offset != 0 {
8265 #[allow(clippy::needless_borrow)]
8266 #[allow(clippy::needless_borrows_for_generic_args)]
8267 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
8268 }
8269 if self.with_ties {
8270 struct_ser.serialize_field("withTies", &self.with_ties)?;
8271 }
8272 struct_ser.end()
8273 }
8274}
8275impl<'de> serde::Deserialize<'de> for TopNNode {
8276 #[allow(deprecated)]
8277 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8278 where
8279 D: serde::Deserializer<'de>,
8280 {
8281 const FIELDS: &[&str] = &[
8282 "column_orders",
8283 "columnOrders",
8284 "limit",
8285 "offset",
8286 "with_ties",
8287 "withTies",
8288 ];
8289
8290 #[allow(clippy::enum_variant_names)]
8291 enum GeneratedField {
8292 ColumnOrders,
8293 Limit,
8294 Offset,
8295 WithTies,
8296 }
8297 impl<'de> serde::Deserialize<'de> for GeneratedField {
8298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8299 where
8300 D: serde::Deserializer<'de>,
8301 {
8302 struct GeneratedVisitor;
8303
8304 impl serde::de::Visitor<'_> for GeneratedVisitor {
8305 type Value = GeneratedField;
8306
8307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8308 write!(formatter, "expected one of: {:?}", &FIELDS)
8309 }
8310
8311 #[allow(unused_variables)]
8312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8313 where
8314 E: serde::de::Error,
8315 {
8316 match value {
8317 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
8318 "limit" => Ok(GeneratedField::Limit),
8319 "offset" => Ok(GeneratedField::Offset),
8320 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
8321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8322 }
8323 }
8324 }
8325 deserializer.deserialize_identifier(GeneratedVisitor)
8326 }
8327 }
8328 struct GeneratedVisitor;
8329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8330 type Value = TopNNode;
8331
8332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8333 formatter.write_str("struct batch_plan.TopNNode")
8334 }
8335
8336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
8337 where
8338 V: serde::de::MapAccess<'de>,
8339 {
8340 let mut column_orders__ = None;
8341 let mut limit__ = None;
8342 let mut offset__ = None;
8343 let mut with_ties__ = None;
8344 while let Some(k) = map_.next_key()? {
8345 match k {
8346 GeneratedField::ColumnOrders => {
8347 if column_orders__.is_some() {
8348 return Err(serde::de::Error::duplicate_field("columnOrders"));
8349 }
8350 column_orders__ = Some(map_.next_value()?);
8351 }
8352 GeneratedField::Limit => {
8353 if limit__.is_some() {
8354 return Err(serde::de::Error::duplicate_field("limit"));
8355 }
8356 limit__ =
8357 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8358 ;
8359 }
8360 GeneratedField::Offset => {
8361 if offset__.is_some() {
8362 return Err(serde::de::Error::duplicate_field("offset"));
8363 }
8364 offset__ =
8365 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8366 ;
8367 }
8368 GeneratedField::WithTies => {
8369 if with_ties__.is_some() {
8370 return Err(serde::de::Error::duplicate_field("withTies"));
8371 }
8372 with_ties__ = Some(map_.next_value()?);
8373 }
8374 }
8375 }
8376 Ok(TopNNode {
8377 column_orders: column_orders__.unwrap_or_default(),
8378 limit: limit__.unwrap_or_default(),
8379 offset: offset__.unwrap_or_default(),
8380 with_ties: with_ties__.unwrap_or_default(),
8381 })
8382 }
8383 }
8384 deserializer.deserialize_struct("batch_plan.TopNNode", FIELDS, GeneratedVisitor)
8385 }
8386}
8387impl serde::Serialize for UnionNode {
8388 #[allow(deprecated)]
8389 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8390 where
8391 S: serde::Serializer,
8392 {
8393 use serde::ser::SerializeStruct;
8394 let len = 0;
8395 let struct_ser = serializer.serialize_struct("batch_plan.UnionNode", len)?;
8396 struct_ser.end()
8397 }
8398}
8399impl<'de> serde::Deserialize<'de> for UnionNode {
8400 #[allow(deprecated)]
8401 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8402 where
8403 D: serde::Deserializer<'de>,
8404 {
8405 const FIELDS: &[&str] = &[
8406 ];
8407
8408 #[allow(clippy::enum_variant_names)]
8409 enum GeneratedField {
8410 }
8411 impl<'de> serde::Deserialize<'de> for GeneratedField {
8412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8413 where
8414 D: serde::Deserializer<'de>,
8415 {
8416 struct GeneratedVisitor;
8417
8418 impl serde::de::Visitor<'_> for GeneratedVisitor {
8419 type Value = GeneratedField;
8420
8421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8422 write!(formatter, "expected one of: {:?}", &FIELDS)
8423 }
8424
8425 #[allow(unused_variables)]
8426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8427 where
8428 E: serde::de::Error,
8429 {
8430 Err(serde::de::Error::unknown_field(value, FIELDS))
8431 }
8432 }
8433 deserializer.deserialize_identifier(GeneratedVisitor)
8434 }
8435 }
8436 struct GeneratedVisitor;
8437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8438 type Value = UnionNode;
8439
8440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8441 formatter.write_str("struct batch_plan.UnionNode")
8442 }
8443
8444 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
8445 where
8446 V: serde::de::MapAccess<'de>,
8447 {
8448 while map_.next_key::<GeneratedField>()?.is_some() {
8449 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8450 }
8451 Ok(UnionNode {
8452 })
8453 }
8454 }
8455 deserializer.deserialize_struct("batch_plan.UnionNode", FIELDS, GeneratedVisitor)
8456 }
8457}
8458impl serde::Serialize for UpdateNode {
8459 #[allow(deprecated)]
8460 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8461 where
8462 S: serde::Serializer,
8463 {
8464 use serde::ser::SerializeStruct;
8465 let mut len = 0;
8466 if self.table_id != 0 {
8467 len += 1;
8468 }
8469 if self.table_version_id != 0 {
8470 len += 1;
8471 }
8472 if !self.old_exprs.is_empty() {
8473 len += 1;
8474 }
8475 if !self.new_exprs.is_empty() {
8476 len += 1;
8477 }
8478 if self.returning {
8479 len += 1;
8480 }
8481 if self.upsert {
8482 len += 1;
8483 }
8484 if self.session_id != 0 {
8485 len += 1;
8486 }
8487 if self.wait_for_persistence {
8488 len += 1;
8489 }
8490 let mut struct_ser = serializer.serialize_struct("batch_plan.UpdateNode", len)?;
8491 if self.table_id != 0 {
8492 struct_ser.serialize_field("tableId", &self.table_id)?;
8493 }
8494 if self.table_version_id != 0 {
8495 #[allow(clippy::needless_borrow)]
8496 #[allow(clippy::needless_borrows_for_generic_args)]
8497 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
8498 }
8499 if !self.old_exprs.is_empty() {
8500 struct_ser.serialize_field("oldExprs", &self.old_exprs)?;
8501 }
8502 if !self.new_exprs.is_empty() {
8503 struct_ser.serialize_field("newExprs", &self.new_exprs)?;
8504 }
8505 if self.returning {
8506 struct_ser.serialize_field("returning", &self.returning)?;
8507 }
8508 if self.upsert {
8509 struct_ser.serialize_field("upsert", &self.upsert)?;
8510 }
8511 if self.session_id != 0 {
8512 struct_ser.serialize_field("sessionId", &self.session_id)?;
8513 }
8514 if self.wait_for_persistence {
8515 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
8516 }
8517 struct_ser.end()
8518 }
8519}
8520impl<'de> serde::Deserialize<'de> for UpdateNode {
8521 #[allow(deprecated)]
8522 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8523 where
8524 D: serde::Deserializer<'de>,
8525 {
8526 const FIELDS: &[&str] = &[
8527 "table_id",
8528 "tableId",
8529 "table_version_id",
8530 "tableVersionId",
8531 "old_exprs",
8532 "oldExprs",
8533 "new_exprs",
8534 "newExprs",
8535 "returning",
8536 "upsert",
8537 "session_id",
8538 "sessionId",
8539 "wait_for_persistence",
8540 "waitForPersistence",
8541 ];
8542
8543 #[allow(clippy::enum_variant_names)]
8544 enum GeneratedField {
8545 TableId,
8546 TableVersionId,
8547 OldExprs,
8548 NewExprs,
8549 Returning,
8550 Upsert,
8551 SessionId,
8552 WaitForPersistence,
8553 }
8554 impl<'de> serde::Deserialize<'de> for GeneratedField {
8555 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8556 where
8557 D: serde::Deserializer<'de>,
8558 {
8559 struct GeneratedVisitor;
8560
8561 impl serde::de::Visitor<'_> for GeneratedVisitor {
8562 type Value = GeneratedField;
8563
8564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8565 write!(formatter, "expected one of: {:?}", &FIELDS)
8566 }
8567
8568 #[allow(unused_variables)]
8569 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8570 where
8571 E: serde::de::Error,
8572 {
8573 match value {
8574 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8575 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
8576 "oldExprs" | "old_exprs" => Ok(GeneratedField::OldExprs),
8577 "newExprs" | "new_exprs" => Ok(GeneratedField::NewExprs),
8578 "returning" => Ok(GeneratedField::Returning),
8579 "upsert" => Ok(GeneratedField::Upsert),
8580 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
8581 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
8582 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8583 }
8584 }
8585 }
8586 deserializer.deserialize_identifier(GeneratedVisitor)
8587 }
8588 }
8589 struct GeneratedVisitor;
8590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8591 type Value = UpdateNode;
8592
8593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8594 formatter.write_str("struct batch_plan.UpdateNode")
8595 }
8596
8597 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateNode, V::Error>
8598 where
8599 V: serde::de::MapAccess<'de>,
8600 {
8601 let mut table_id__ = None;
8602 let mut table_version_id__ = None;
8603 let mut old_exprs__ = None;
8604 let mut new_exprs__ = None;
8605 let mut returning__ = None;
8606 let mut upsert__ = None;
8607 let mut session_id__ = None;
8608 let mut wait_for_persistence__ = None;
8609 while let Some(k) = map_.next_key()? {
8610 match k {
8611 GeneratedField::TableId => {
8612 if table_id__.is_some() {
8613 return Err(serde::de::Error::duplicate_field("tableId"));
8614 }
8615 table_id__ =
8616 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8617 ;
8618 }
8619 GeneratedField::TableVersionId => {
8620 if table_version_id__.is_some() {
8621 return Err(serde::de::Error::duplicate_field("tableVersionId"));
8622 }
8623 table_version_id__ =
8624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8625 ;
8626 }
8627 GeneratedField::OldExprs => {
8628 if old_exprs__.is_some() {
8629 return Err(serde::de::Error::duplicate_field("oldExprs"));
8630 }
8631 old_exprs__ = Some(map_.next_value()?);
8632 }
8633 GeneratedField::NewExprs => {
8634 if new_exprs__.is_some() {
8635 return Err(serde::de::Error::duplicate_field("newExprs"));
8636 }
8637 new_exprs__ = Some(map_.next_value()?);
8638 }
8639 GeneratedField::Returning => {
8640 if returning__.is_some() {
8641 return Err(serde::de::Error::duplicate_field("returning"));
8642 }
8643 returning__ = Some(map_.next_value()?);
8644 }
8645 GeneratedField::Upsert => {
8646 if upsert__.is_some() {
8647 return Err(serde::de::Error::duplicate_field("upsert"));
8648 }
8649 upsert__ = Some(map_.next_value()?);
8650 }
8651 GeneratedField::SessionId => {
8652 if session_id__.is_some() {
8653 return Err(serde::de::Error::duplicate_field("sessionId"));
8654 }
8655 session_id__ =
8656 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8657 ;
8658 }
8659 GeneratedField::WaitForPersistence => {
8660 if wait_for_persistence__.is_some() {
8661 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
8662 }
8663 wait_for_persistence__ = Some(map_.next_value()?);
8664 }
8665 }
8666 }
8667 Ok(UpdateNode {
8668 table_id: table_id__.unwrap_or_default(),
8669 table_version_id: table_version_id__.unwrap_or_default(),
8670 old_exprs: old_exprs__.unwrap_or_default(),
8671 new_exprs: new_exprs__.unwrap_or_default(),
8672 returning: returning__.unwrap_or_default(),
8673 upsert: upsert__.unwrap_or_default(),
8674 session_id: session_id__.unwrap_or_default(),
8675 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
8676 })
8677 }
8678 }
8679 deserializer.deserialize_struct("batch_plan.UpdateNode", FIELDS, GeneratedVisitor)
8680 }
8681}
8682impl serde::Serialize for ValuesNode {
8683 #[allow(deprecated)]
8684 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8685 where
8686 S: serde::Serializer,
8687 {
8688 use serde::ser::SerializeStruct;
8689 let mut len = 0;
8690 if !self.tuples.is_empty() {
8691 len += 1;
8692 }
8693 if !self.fields.is_empty() {
8694 len += 1;
8695 }
8696 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode", len)?;
8697 if !self.tuples.is_empty() {
8698 struct_ser.serialize_field("tuples", &self.tuples)?;
8699 }
8700 if !self.fields.is_empty() {
8701 struct_ser.serialize_field("fields", &self.fields)?;
8702 }
8703 struct_ser.end()
8704 }
8705}
8706impl<'de> serde::Deserialize<'de> for ValuesNode {
8707 #[allow(deprecated)]
8708 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8709 where
8710 D: serde::Deserializer<'de>,
8711 {
8712 const FIELDS: &[&str] = &[
8713 "tuples",
8714 "fields",
8715 ];
8716
8717 #[allow(clippy::enum_variant_names)]
8718 enum GeneratedField {
8719 Tuples,
8720 Fields,
8721 }
8722 impl<'de> serde::Deserialize<'de> for GeneratedField {
8723 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8724 where
8725 D: serde::Deserializer<'de>,
8726 {
8727 struct GeneratedVisitor;
8728
8729 impl serde::de::Visitor<'_> for GeneratedVisitor {
8730 type Value = GeneratedField;
8731
8732 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8733 write!(formatter, "expected one of: {:?}", &FIELDS)
8734 }
8735
8736 #[allow(unused_variables)]
8737 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8738 where
8739 E: serde::de::Error,
8740 {
8741 match value {
8742 "tuples" => Ok(GeneratedField::Tuples),
8743 "fields" => Ok(GeneratedField::Fields),
8744 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8745 }
8746 }
8747 }
8748 deserializer.deserialize_identifier(GeneratedVisitor)
8749 }
8750 }
8751 struct GeneratedVisitor;
8752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8753 type Value = ValuesNode;
8754
8755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8756 formatter.write_str("struct batch_plan.ValuesNode")
8757 }
8758
8759 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
8760 where
8761 V: serde::de::MapAccess<'de>,
8762 {
8763 let mut tuples__ = None;
8764 let mut fields__ = None;
8765 while let Some(k) = map_.next_key()? {
8766 match k {
8767 GeneratedField::Tuples => {
8768 if tuples__.is_some() {
8769 return Err(serde::de::Error::duplicate_field("tuples"));
8770 }
8771 tuples__ = Some(map_.next_value()?);
8772 }
8773 GeneratedField::Fields => {
8774 if fields__.is_some() {
8775 return Err(serde::de::Error::duplicate_field("fields"));
8776 }
8777 fields__ = Some(map_.next_value()?);
8778 }
8779 }
8780 }
8781 Ok(ValuesNode {
8782 tuples: tuples__.unwrap_or_default(),
8783 fields: fields__.unwrap_or_default(),
8784 })
8785 }
8786 }
8787 deserializer.deserialize_struct("batch_plan.ValuesNode", FIELDS, GeneratedVisitor)
8788 }
8789}
8790impl serde::Serialize for values_node::ExprTuple {
8791 #[allow(deprecated)]
8792 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8793 where
8794 S: serde::Serializer,
8795 {
8796 use serde::ser::SerializeStruct;
8797 let mut len = 0;
8798 if !self.cells.is_empty() {
8799 len += 1;
8800 }
8801 let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode.ExprTuple", len)?;
8802 if !self.cells.is_empty() {
8803 struct_ser.serialize_field("cells", &self.cells)?;
8804 }
8805 struct_ser.end()
8806 }
8807}
8808impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
8809 #[allow(deprecated)]
8810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8811 where
8812 D: serde::Deserializer<'de>,
8813 {
8814 const FIELDS: &[&str] = &[
8815 "cells",
8816 ];
8817
8818 #[allow(clippy::enum_variant_names)]
8819 enum GeneratedField {
8820 Cells,
8821 }
8822 impl<'de> serde::Deserialize<'de> for GeneratedField {
8823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8824 where
8825 D: serde::Deserializer<'de>,
8826 {
8827 struct GeneratedVisitor;
8828
8829 impl serde::de::Visitor<'_> for GeneratedVisitor {
8830 type Value = GeneratedField;
8831
8832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8833 write!(formatter, "expected one of: {:?}", &FIELDS)
8834 }
8835
8836 #[allow(unused_variables)]
8837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8838 where
8839 E: serde::de::Error,
8840 {
8841 match value {
8842 "cells" => Ok(GeneratedField::Cells),
8843 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8844 }
8845 }
8846 }
8847 deserializer.deserialize_identifier(GeneratedVisitor)
8848 }
8849 }
8850 struct GeneratedVisitor;
8851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8852 type Value = values_node::ExprTuple;
8853
8854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8855 formatter.write_str("struct batch_plan.ValuesNode.ExprTuple")
8856 }
8857
8858 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
8859 where
8860 V: serde::de::MapAccess<'de>,
8861 {
8862 let mut cells__ = None;
8863 while let Some(k) = map_.next_key()? {
8864 match k {
8865 GeneratedField::Cells => {
8866 if cells__.is_some() {
8867 return Err(serde::de::Error::duplicate_field("cells"));
8868 }
8869 cells__ = Some(map_.next_value()?);
8870 }
8871 }
8872 }
8873 Ok(values_node::ExprTuple {
8874 cells: cells__.unwrap_or_default(),
8875 })
8876 }
8877 }
8878 deserializer.deserialize_struct("batch_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
8879 }
8880}
8881impl serde::Serialize for VectorIndexNearestNode {
8882 #[allow(deprecated)]
8883 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8884 where
8885 S: serde::Serializer,
8886 {
8887 use serde::ser::SerializeStruct;
8888 let mut len = 0;
8889 if self.reader_desc.is_some() {
8890 len += 1;
8891 }
8892 if self.vector_column_idx != 0 {
8893 len += 1;
8894 }
8895 if self.query_epoch.is_some() {
8896 len += 1;
8897 }
8898 let mut struct_ser = serializer.serialize_struct("batch_plan.VectorIndexNearestNode", len)?;
8899 if let Some(v) = self.reader_desc.as_ref() {
8900 struct_ser.serialize_field("readerDesc", v)?;
8901 }
8902 if self.vector_column_idx != 0 {
8903 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
8904 }
8905 if let Some(v) = self.query_epoch.as_ref() {
8906 struct_ser.serialize_field("queryEpoch", v)?;
8907 }
8908 struct_ser.end()
8909 }
8910}
8911impl<'de> serde::Deserialize<'de> for VectorIndexNearestNode {
8912 #[allow(deprecated)]
8913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8914 where
8915 D: serde::Deserializer<'de>,
8916 {
8917 const FIELDS: &[&str] = &[
8918 "reader_desc",
8919 "readerDesc",
8920 "vector_column_idx",
8921 "vectorColumnIdx",
8922 "query_epoch",
8923 "queryEpoch",
8924 ];
8925
8926 #[allow(clippy::enum_variant_names)]
8927 enum GeneratedField {
8928 ReaderDesc,
8929 VectorColumnIdx,
8930 QueryEpoch,
8931 }
8932 impl<'de> serde::Deserialize<'de> for GeneratedField {
8933 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8934 where
8935 D: serde::Deserializer<'de>,
8936 {
8937 struct GeneratedVisitor;
8938
8939 impl serde::de::Visitor<'_> for GeneratedVisitor {
8940 type Value = GeneratedField;
8941
8942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8943 write!(formatter, "expected one of: {:?}", &FIELDS)
8944 }
8945
8946 #[allow(unused_variables)]
8947 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8948 where
8949 E: serde::de::Error,
8950 {
8951 match value {
8952 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
8953 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
8954 "queryEpoch" | "query_epoch" => Ok(GeneratedField::QueryEpoch),
8955 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8956 }
8957 }
8958 }
8959 deserializer.deserialize_identifier(GeneratedVisitor)
8960 }
8961 }
8962 struct GeneratedVisitor;
8963 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8964 type Value = VectorIndexNearestNode;
8965
8966 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8967 formatter.write_str("struct batch_plan.VectorIndexNearestNode")
8968 }
8969
8970 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexNearestNode, V::Error>
8971 where
8972 V: serde::de::MapAccess<'de>,
8973 {
8974 let mut reader_desc__ = None;
8975 let mut vector_column_idx__ = None;
8976 let mut query_epoch__ = None;
8977 while let Some(k) = map_.next_key()? {
8978 match k {
8979 GeneratedField::ReaderDesc => {
8980 if reader_desc__.is_some() {
8981 return Err(serde::de::Error::duplicate_field("readerDesc"));
8982 }
8983 reader_desc__ = map_.next_value()?;
8984 }
8985 GeneratedField::VectorColumnIdx => {
8986 if vector_column_idx__.is_some() {
8987 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
8988 }
8989 vector_column_idx__ =
8990 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8991 ;
8992 }
8993 GeneratedField::QueryEpoch => {
8994 if query_epoch__.is_some() {
8995 return Err(serde::de::Error::duplicate_field("queryEpoch"));
8996 }
8997 query_epoch__ = map_.next_value()?;
8998 }
8999 }
9000 }
9001 Ok(VectorIndexNearestNode {
9002 reader_desc: reader_desc__,
9003 vector_column_idx: vector_column_idx__.unwrap_or_default(),
9004 query_epoch: query_epoch__,
9005 })
9006 }
9007 }
9008 deserializer.deserialize_struct("batch_plan.VectorIndexNearestNode", FIELDS, GeneratedVisitor)
9009 }
9010}