1use crate::plan_common::*;
2impl serde::Serialize for AdditionalCollectionName {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let len = 0;
10 let struct_ser = serializer.serialize_struct("plan_common.AdditionalCollectionName", len)?;
11 struct_ser.end()
12 }
13}
14impl<'de> serde::Deserialize<'de> for AdditionalCollectionName {
15 #[allow(deprecated)]
16 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17 where
18 D: serde::Deserializer<'de>,
19 {
20 const FIELDS: &[&str] = &[
21 ];
22
23 #[allow(clippy::enum_variant_names)]
24 enum GeneratedField {
25 }
26 impl<'de> serde::Deserialize<'de> for GeneratedField {
27 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
28 where
29 D: serde::Deserializer<'de>,
30 {
31 struct GeneratedVisitor;
32
33 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
34 type Value = GeneratedField;
35
36 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
37 write!(formatter, "expected one of: {:?}", &FIELDS)
38 }
39
40 #[allow(unused_variables)]
41 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
42 where
43 E: serde::de::Error,
44 {
45 Err(serde::de::Error::unknown_field(value, FIELDS))
46 }
47 }
48 deserializer.deserialize_identifier(GeneratedVisitor)
49 }
50 }
51 struct GeneratedVisitor;
52 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
53 type Value = AdditionalCollectionName;
54
55 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 formatter.write_str("struct plan_common.AdditionalCollectionName")
57 }
58
59 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalCollectionName, V::Error>
60 where
61 V: serde::de::MapAccess<'de>,
62 {
63 while map_.next_key::<GeneratedField>()?.is_some() {
64 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
65 }
66 Ok(AdditionalCollectionName {
67 })
68 }
69 }
70 deserializer.deserialize_struct("plan_common.AdditionalCollectionName", FIELDS, GeneratedVisitor)
71 }
72}
73impl serde::Serialize for AdditionalColumn {
74 #[allow(deprecated)]
75 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
76 where
77 S: serde::Serializer,
78 {
79 use serde::ser::SerializeStruct;
80 let mut len = 0;
81 if self.column_type.is_some() {
82 len += 1;
83 }
84 let mut struct_ser = serializer.serialize_struct("plan_common.AdditionalColumn", len)?;
85 if let Some(v) = self.column_type.as_ref() {
86 match v {
87 additional_column::ColumnType::Key(v) => {
88 struct_ser.serialize_field("key", v)?;
89 }
90 additional_column::ColumnType::Timestamp(v) => {
91 struct_ser.serialize_field("timestamp", v)?;
92 }
93 additional_column::ColumnType::Partition(v) => {
94 struct_ser.serialize_field("partition", v)?;
95 }
96 additional_column::ColumnType::Offset(v) => {
97 struct_ser.serialize_field("offset", v)?;
98 }
99 additional_column::ColumnType::HeaderInner(v) => {
100 struct_ser.serialize_field("headerInner", v)?;
101 }
102 additional_column::ColumnType::Filename(v) => {
103 struct_ser.serialize_field("filename", v)?;
104 }
105 additional_column::ColumnType::Headers(v) => {
106 struct_ser.serialize_field("headers", v)?;
107 }
108 additional_column::ColumnType::DatabaseName(v) => {
109 struct_ser.serialize_field("databaseName", v)?;
110 }
111 additional_column::ColumnType::SchemaName(v) => {
112 struct_ser.serialize_field("schemaName", v)?;
113 }
114 additional_column::ColumnType::TableName(v) => {
115 struct_ser.serialize_field("tableName", v)?;
116 }
117 additional_column::ColumnType::CollectionName(v) => {
118 struct_ser.serialize_field("collectionName", v)?;
119 }
120 additional_column::ColumnType::Payload(v) => {
121 struct_ser.serialize_field("payload", v)?;
122 }
123 additional_column::ColumnType::Subject(v) => {
124 struct_ser.serialize_field("subject", v)?;
125 }
126 }
127 }
128 struct_ser.end()
129 }
130}
131impl<'de> serde::Deserialize<'de> for AdditionalColumn {
132 #[allow(deprecated)]
133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
134 where
135 D: serde::Deserializer<'de>,
136 {
137 const FIELDS: &[&str] = &[
138 "key",
139 "timestamp",
140 "partition",
141 "offset",
142 "header_inner",
143 "headerInner",
144 "filename",
145 "headers",
146 "database_name",
147 "databaseName",
148 "schema_name",
149 "schemaName",
150 "table_name",
151 "tableName",
152 "collection_name",
153 "collectionName",
154 "payload",
155 "subject",
156 ];
157
158 #[allow(clippy::enum_variant_names)]
159 enum GeneratedField {
160 Key,
161 Timestamp,
162 Partition,
163 Offset,
164 HeaderInner,
165 Filename,
166 Headers,
167 DatabaseName,
168 SchemaName,
169 TableName,
170 CollectionName,
171 Payload,
172 Subject,
173 }
174 impl<'de> serde::Deserialize<'de> for GeneratedField {
175 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
176 where
177 D: serde::Deserializer<'de>,
178 {
179 struct GeneratedVisitor;
180
181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
182 type Value = GeneratedField;
183
184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
185 write!(formatter, "expected one of: {:?}", &FIELDS)
186 }
187
188 #[allow(unused_variables)]
189 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
190 where
191 E: serde::de::Error,
192 {
193 match value {
194 "key" => Ok(GeneratedField::Key),
195 "timestamp" => Ok(GeneratedField::Timestamp),
196 "partition" => Ok(GeneratedField::Partition),
197 "offset" => Ok(GeneratedField::Offset),
198 "headerInner" | "header_inner" => Ok(GeneratedField::HeaderInner),
199 "filename" => Ok(GeneratedField::Filename),
200 "headers" => Ok(GeneratedField::Headers),
201 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
202 "schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
203 "tableName" | "table_name" => Ok(GeneratedField::TableName),
204 "collectionName" | "collection_name" => Ok(GeneratedField::CollectionName),
205 "payload" => Ok(GeneratedField::Payload),
206 "subject" => Ok(GeneratedField::Subject),
207 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
208 }
209 }
210 }
211 deserializer.deserialize_identifier(GeneratedVisitor)
212 }
213 }
214 struct GeneratedVisitor;
215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
216 type Value = AdditionalColumn;
217
218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
219 formatter.write_str("struct plan_common.AdditionalColumn")
220 }
221
222 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalColumn, V::Error>
223 where
224 V: serde::de::MapAccess<'de>,
225 {
226 let mut column_type__ = None;
227 while let Some(k) = map_.next_key()? {
228 match k {
229 GeneratedField::Key => {
230 if column_type__.is_some() {
231 return Err(serde::de::Error::duplicate_field("key"));
232 }
233 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::Key)
234;
235 }
236 GeneratedField::Timestamp => {
237 if column_type__.is_some() {
238 return Err(serde::de::Error::duplicate_field("timestamp"));
239 }
240 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::Timestamp)
241;
242 }
243 GeneratedField::Partition => {
244 if column_type__.is_some() {
245 return Err(serde::de::Error::duplicate_field("partition"));
246 }
247 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::Partition)
248;
249 }
250 GeneratedField::Offset => {
251 if column_type__.is_some() {
252 return Err(serde::de::Error::duplicate_field("offset"));
253 }
254 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::Offset)
255;
256 }
257 GeneratedField::HeaderInner => {
258 if column_type__.is_some() {
259 return Err(serde::de::Error::duplicate_field("headerInner"));
260 }
261 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::HeaderInner)
262;
263 }
264 GeneratedField::Filename => {
265 if column_type__.is_some() {
266 return Err(serde::de::Error::duplicate_field("filename"));
267 }
268 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::Filename)
269;
270 }
271 GeneratedField::Headers => {
272 if column_type__.is_some() {
273 return Err(serde::de::Error::duplicate_field("headers"));
274 }
275 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::Headers)
276;
277 }
278 GeneratedField::DatabaseName => {
279 if column_type__.is_some() {
280 return Err(serde::de::Error::duplicate_field("databaseName"));
281 }
282 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::DatabaseName)
283;
284 }
285 GeneratedField::SchemaName => {
286 if column_type__.is_some() {
287 return Err(serde::de::Error::duplicate_field("schemaName"));
288 }
289 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::SchemaName)
290;
291 }
292 GeneratedField::TableName => {
293 if column_type__.is_some() {
294 return Err(serde::de::Error::duplicate_field("tableName"));
295 }
296 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::TableName)
297;
298 }
299 GeneratedField::CollectionName => {
300 if column_type__.is_some() {
301 return Err(serde::de::Error::duplicate_field("collectionName"));
302 }
303 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::CollectionName)
304;
305 }
306 GeneratedField::Payload => {
307 if column_type__.is_some() {
308 return Err(serde::de::Error::duplicate_field("payload"));
309 }
310 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::Payload)
311;
312 }
313 GeneratedField::Subject => {
314 if column_type__.is_some() {
315 return Err(serde::de::Error::duplicate_field("subject"));
316 }
317 column_type__ = map_.next_value::<::std::option::Option<_>>()?.map(additional_column::ColumnType::Subject)
318;
319 }
320 }
321 }
322 Ok(AdditionalColumn {
323 column_type: column_type__,
324 })
325 }
326 }
327 deserializer.deserialize_struct("plan_common.AdditionalColumn", FIELDS, GeneratedVisitor)
328 }
329}
330impl serde::Serialize for AdditionalColumnFilename {
331 #[allow(deprecated)]
332 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
333 where
334 S: serde::Serializer,
335 {
336 use serde::ser::SerializeStruct;
337 let len = 0;
338 let struct_ser = serializer.serialize_struct("plan_common.AdditionalColumnFilename", len)?;
339 struct_ser.end()
340 }
341}
342impl<'de> serde::Deserialize<'de> for AdditionalColumnFilename {
343 #[allow(deprecated)]
344 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
345 where
346 D: serde::Deserializer<'de>,
347 {
348 const FIELDS: &[&str] = &[
349 ];
350
351 #[allow(clippy::enum_variant_names)]
352 enum GeneratedField {
353 }
354 impl<'de> serde::Deserialize<'de> for GeneratedField {
355 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
356 where
357 D: serde::Deserializer<'de>,
358 {
359 struct GeneratedVisitor;
360
361 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
362 type Value = GeneratedField;
363
364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
365 write!(formatter, "expected one of: {:?}", &FIELDS)
366 }
367
368 #[allow(unused_variables)]
369 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
370 where
371 E: serde::de::Error,
372 {
373 Err(serde::de::Error::unknown_field(value, FIELDS))
374 }
375 }
376 deserializer.deserialize_identifier(GeneratedVisitor)
377 }
378 }
379 struct GeneratedVisitor;
380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
381 type Value = AdditionalColumnFilename;
382
383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
384 formatter.write_str("struct plan_common.AdditionalColumnFilename")
385 }
386
387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalColumnFilename, V::Error>
388 where
389 V: serde::de::MapAccess<'de>,
390 {
391 while map_.next_key::<GeneratedField>()?.is_some() {
392 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
393 }
394 Ok(AdditionalColumnFilename {
395 })
396 }
397 }
398 deserializer.deserialize_struct("plan_common.AdditionalColumnFilename", FIELDS, GeneratedVisitor)
399 }
400}
401impl serde::Serialize for AdditionalColumnHeader {
402 #[allow(deprecated)]
403 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
404 where
405 S: serde::Serializer,
406 {
407 use serde::ser::SerializeStruct;
408 let mut len = 0;
409 if !self.inner_field.is_empty() {
410 len += 1;
411 }
412 if self.data_type.is_some() {
413 len += 1;
414 }
415 let mut struct_ser = serializer.serialize_struct("plan_common.AdditionalColumnHeader", len)?;
416 if !self.inner_field.is_empty() {
417 struct_ser.serialize_field("innerField", &self.inner_field)?;
418 }
419 if let Some(v) = self.data_type.as_ref() {
420 struct_ser.serialize_field("dataType", v)?;
421 }
422 struct_ser.end()
423 }
424}
425impl<'de> serde::Deserialize<'de> for AdditionalColumnHeader {
426 #[allow(deprecated)]
427 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
428 where
429 D: serde::Deserializer<'de>,
430 {
431 const FIELDS: &[&str] = &[
432 "inner_field",
433 "innerField",
434 "data_type",
435 "dataType",
436 ];
437
438 #[allow(clippy::enum_variant_names)]
439 enum GeneratedField {
440 InnerField,
441 DataType,
442 }
443 impl<'de> serde::Deserialize<'de> for GeneratedField {
444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
445 where
446 D: serde::Deserializer<'de>,
447 {
448 struct GeneratedVisitor;
449
450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
451 type Value = GeneratedField;
452
453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
454 write!(formatter, "expected one of: {:?}", &FIELDS)
455 }
456
457 #[allow(unused_variables)]
458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
459 where
460 E: serde::de::Error,
461 {
462 match value {
463 "innerField" | "inner_field" => Ok(GeneratedField::InnerField),
464 "dataType" | "data_type" => Ok(GeneratedField::DataType),
465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
466 }
467 }
468 }
469 deserializer.deserialize_identifier(GeneratedVisitor)
470 }
471 }
472 struct GeneratedVisitor;
473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
474 type Value = AdditionalColumnHeader;
475
476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
477 formatter.write_str("struct plan_common.AdditionalColumnHeader")
478 }
479
480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalColumnHeader, V::Error>
481 where
482 V: serde::de::MapAccess<'de>,
483 {
484 let mut inner_field__ = None;
485 let mut data_type__ = None;
486 while let Some(k) = map_.next_key()? {
487 match k {
488 GeneratedField::InnerField => {
489 if inner_field__.is_some() {
490 return Err(serde::de::Error::duplicate_field("innerField"));
491 }
492 inner_field__ = Some(map_.next_value()?);
493 }
494 GeneratedField::DataType => {
495 if data_type__.is_some() {
496 return Err(serde::de::Error::duplicate_field("dataType"));
497 }
498 data_type__ = map_.next_value()?;
499 }
500 }
501 }
502 Ok(AdditionalColumnHeader {
503 inner_field: inner_field__.unwrap_or_default(),
504 data_type: data_type__,
505 })
506 }
507 }
508 deserializer.deserialize_struct("plan_common.AdditionalColumnHeader", FIELDS, GeneratedVisitor)
509 }
510}
511impl serde::Serialize for AdditionalColumnHeaders {
512 #[allow(deprecated)]
513 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
514 where
515 S: serde::Serializer,
516 {
517 use serde::ser::SerializeStruct;
518 let len = 0;
519 let struct_ser = serializer.serialize_struct("plan_common.AdditionalColumnHeaders", len)?;
520 struct_ser.end()
521 }
522}
523impl<'de> serde::Deserialize<'de> for AdditionalColumnHeaders {
524 #[allow(deprecated)]
525 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
526 where
527 D: serde::Deserializer<'de>,
528 {
529 const FIELDS: &[&str] = &[
530 ];
531
532 #[allow(clippy::enum_variant_names)]
533 enum GeneratedField {
534 }
535 impl<'de> serde::Deserialize<'de> for GeneratedField {
536 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
537 where
538 D: serde::Deserializer<'de>,
539 {
540 struct GeneratedVisitor;
541
542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
543 type Value = GeneratedField;
544
545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
546 write!(formatter, "expected one of: {:?}", &FIELDS)
547 }
548
549 #[allow(unused_variables)]
550 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
551 where
552 E: serde::de::Error,
553 {
554 Err(serde::de::Error::unknown_field(value, FIELDS))
555 }
556 }
557 deserializer.deserialize_identifier(GeneratedVisitor)
558 }
559 }
560 struct GeneratedVisitor;
561 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
562 type Value = AdditionalColumnHeaders;
563
564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
565 formatter.write_str("struct plan_common.AdditionalColumnHeaders")
566 }
567
568 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalColumnHeaders, V::Error>
569 where
570 V: serde::de::MapAccess<'de>,
571 {
572 while map_.next_key::<GeneratedField>()?.is_some() {
573 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
574 }
575 Ok(AdditionalColumnHeaders {
576 })
577 }
578 }
579 deserializer.deserialize_struct("plan_common.AdditionalColumnHeaders", FIELDS, GeneratedVisitor)
580 }
581}
582impl serde::Serialize for AdditionalColumnKey {
583 #[allow(deprecated)]
584 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
585 where
586 S: serde::Serializer,
587 {
588 use serde::ser::SerializeStruct;
589 let len = 0;
590 let struct_ser = serializer.serialize_struct("plan_common.AdditionalColumnKey", len)?;
591 struct_ser.end()
592 }
593}
594impl<'de> serde::Deserialize<'de> for AdditionalColumnKey {
595 #[allow(deprecated)]
596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
597 where
598 D: serde::Deserializer<'de>,
599 {
600 const FIELDS: &[&str] = &[
601 ];
602
603 #[allow(clippy::enum_variant_names)]
604 enum GeneratedField {
605 }
606 impl<'de> serde::Deserialize<'de> for GeneratedField {
607 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
608 where
609 D: serde::Deserializer<'de>,
610 {
611 struct GeneratedVisitor;
612
613 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
614 type Value = GeneratedField;
615
616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
617 write!(formatter, "expected one of: {:?}", &FIELDS)
618 }
619
620 #[allow(unused_variables)]
621 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
622 where
623 E: serde::de::Error,
624 {
625 Err(serde::de::Error::unknown_field(value, FIELDS))
626 }
627 }
628 deserializer.deserialize_identifier(GeneratedVisitor)
629 }
630 }
631 struct GeneratedVisitor;
632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
633 type Value = AdditionalColumnKey;
634
635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
636 formatter.write_str("struct plan_common.AdditionalColumnKey")
637 }
638
639 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalColumnKey, V::Error>
640 where
641 V: serde::de::MapAccess<'de>,
642 {
643 while map_.next_key::<GeneratedField>()?.is_some() {
644 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
645 }
646 Ok(AdditionalColumnKey {
647 })
648 }
649 }
650 deserializer.deserialize_struct("plan_common.AdditionalColumnKey", FIELDS, GeneratedVisitor)
651 }
652}
653impl serde::Serialize for AdditionalColumnOffset {
654 #[allow(deprecated)]
655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
656 where
657 S: serde::Serializer,
658 {
659 use serde::ser::SerializeStruct;
660 let len = 0;
661 let struct_ser = serializer.serialize_struct("plan_common.AdditionalColumnOffset", len)?;
662 struct_ser.end()
663 }
664}
665impl<'de> serde::Deserialize<'de> for AdditionalColumnOffset {
666 #[allow(deprecated)]
667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
668 where
669 D: serde::Deserializer<'de>,
670 {
671 const FIELDS: &[&str] = &[
672 ];
673
674 #[allow(clippy::enum_variant_names)]
675 enum GeneratedField {
676 }
677 impl<'de> serde::Deserialize<'de> for GeneratedField {
678 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
679 where
680 D: serde::Deserializer<'de>,
681 {
682 struct GeneratedVisitor;
683
684 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
685 type Value = GeneratedField;
686
687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
688 write!(formatter, "expected one of: {:?}", &FIELDS)
689 }
690
691 #[allow(unused_variables)]
692 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
693 where
694 E: serde::de::Error,
695 {
696 Err(serde::de::Error::unknown_field(value, FIELDS))
697 }
698 }
699 deserializer.deserialize_identifier(GeneratedVisitor)
700 }
701 }
702 struct GeneratedVisitor;
703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
704 type Value = AdditionalColumnOffset;
705
706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
707 formatter.write_str("struct plan_common.AdditionalColumnOffset")
708 }
709
710 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalColumnOffset, V::Error>
711 where
712 V: serde::de::MapAccess<'de>,
713 {
714 while map_.next_key::<GeneratedField>()?.is_some() {
715 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
716 }
717 Ok(AdditionalColumnOffset {
718 })
719 }
720 }
721 deserializer.deserialize_struct("plan_common.AdditionalColumnOffset", FIELDS, GeneratedVisitor)
722 }
723}
724impl serde::Serialize for AdditionalColumnPartition {
725 #[allow(deprecated)]
726 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
727 where
728 S: serde::Serializer,
729 {
730 use serde::ser::SerializeStruct;
731 let len = 0;
732 let struct_ser = serializer.serialize_struct("plan_common.AdditionalColumnPartition", len)?;
733 struct_ser.end()
734 }
735}
736impl<'de> serde::Deserialize<'de> for AdditionalColumnPartition {
737 #[allow(deprecated)]
738 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
739 where
740 D: serde::Deserializer<'de>,
741 {
742 const FIELDS: &[&str] = &[
743 ];
744
745 #[allow(clippy::enum_variant_names)]
746 enum GeneratedField {
747 }
748 impl<'de> serde::Deserialize<'de> for GeneratedField {
749 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
750 where
751 D: serde::Deserializer<'de>,
752 {
753 struct GeneratedVisitor;
754
755 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
756 type Value = GeneratedField;
757
758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
759 write!(formatter, "expected one of: {:?}", &FIELDS)
760 }
761
762 #[allow(unused_variables)]
763 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
764 where
765 E: serde::de::Error,
766 {
767 Err(serde::de::Error::unknown_field(value, FIELDS))
768 }
769 }
770 deserializer.deserialize_identifier(GeneratedVisitor)
771 }
772 }
773 struct GeneratedVisitor;
774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
775 type Value = AdditionalColumnPartition;
776
777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
778 formatter.write_str("struct plan_common.AdditionalColumnPartition")
779 }
780
781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalColumnPartition, V::Error>
782 where
783 V: serde::de::MapAccess<'de>,
784 {
785 while map_.next_key::<GeneratedField>()?.is_some() {
786 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
787 }
788 Ok(AdditionalColumnPartition {
789 })
790 }
791 }
792 deserializer.deserialize_struct("plan_common.AdditionalColumnPartition", FIELDS, GeneratedVisitor)
793 }
794}
795impl serde::Serialize for AdditionalColumnPayload {
796 #[allow(deprecated)]
797 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
798 where
799 S: serde::Serializer,
800 {
801 use serde::ser::SerializeStruct;
802 let len = 0;
803 let struct_ser = serializer.serialize_struct("plan_common.AdditionalColumnPayload", len)?;
804 struct_ser.end()
805 }
806}
807impl<'de> serde::Deserialize<'de> for AdditionalColumnPayload {
808 #[allow(deprecated)]
809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
810 where
811 D: serde::Deserializer<'de>,
812 {
813 const FIELDS: &[&str] = &[
814 ];
815
816 #[allow(clippy::enum_variant_names)]
817 enum GeneratedField {
818 }
819 impl<'de> serde::Deserialize<'de> for GeneratedField {
820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
821 where
822 D: serde::Deserializer<'de>,
823 {
824 struct GeneratedVisitor;
825
826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
827 type Value = GeneratedField;
828
829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
830 write!(formatter, "expected one of: {:?}", &FIELDS)
831 }
832
833 #[allow(unused_variables)]
834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
835 where
836 E: serde::de::Error,
837 {
838 Err(serde::de::Error::unknown_field(value, FIELDS))
839 }
840 }
841 deserializer.deserialize_identifier(GeneratedVisitor)
842 }
843 }
844 struct GeneratedVisitor;
845 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
846 type Value = AdditionalColumnPayload;
847
848 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
849 formatter.write_str("struct plan_common.AdditionalColumnPayload")
850 }
851
852 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalColumnPayload, V::Error>
853 where
854 V: serde::de::MapAccess<'de>,
855 {
856 while map_.next_key::<GeneratedField>()?.is_some() {
857 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
858 }
859 Ok(AdditionalColumnPayload {
860 })
861 }
862 }
863 deserializer.deserialize_struct("plan_common.AdditionalColumnPayload", FIELDS, GeneratedVisitor)
864 }
865}
866impl serde::Serialize for AdditionalColumnTimestamp {
867 #[allow(deprecated)]
868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
869 where
870 S: serde::Serializer,
871 {
872 use serde::ser::SerializeStruct;
873 let len = 0;
874 let struct_ser = serializer.serialize_struct("plan_common.AdditionalColumnTimestamp", len)?;
875 struct_ser.end()
876 }
877}
878impl<'de> serde::Deserialize<'de> for AdditionalColumnTimestamp {
879 #[allow(deprecated)]
880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
881 where
882 D: serde::Deserializer<'de>,
883 {
884 const FIELDS: &[&str] = &[
885 ];
886
887 #[allow(clippy::enum_variant_names)]
888 enum GeneratedField {
889 }
890 impl<'de> serde::Deserialize<'de> for GeneratedField {
891 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
892 where
893 D: serde::Deserializer<'de>,
894 {
895 struct GeneratedVisitor;
896
897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
898 type Value = GeneratedField;
899
900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
901 write!(formatter, "expected one of: {:?}", &FIELDS)
902 }
903
904 #[allow(unused_variables)]
905 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
906 where
907 E: serde::de::Error,
908 {
909 Err(serde::de::Error::unknown_field(value, FIELDS))
910 }
911 }
912 deserializer.deserialize_identifier(GeneratedVisitor)
913 }
914 }
915 struct GeneratedVisitor;
916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
917 type Value = AdditionalColumnTimestamp;
918
919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
920 formatter.write_str("struct plan_common.AdditionalColumnTimestamp")
921 }
922
923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalColumnTimestamp, V::Error>
924 where
925 V: serde::de::MapAccess<'de>,
926 {
927 while map_.next_key::<GeneratedField>()?.is_some() {
928 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
929 }
930 Ok(AdditionalColumnTimestamp {
931 })
932 }
933 }
934 deserializer.deserialize_struct("plan_common.AdditionalColumnTimestamp", FIELDS, GeneratedVisitor)
935 }
936}
937impl serde::Serialize for AdditionalColumnType {
938 #[allow(deprecated)]
939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
940 where
941 S: serde::Serializer,
942 {
943 let variant = match self {
944 Self::Unspecified => "ADDITIONAL_COLUMN_TYPE_UNSPECIFIED",
945 Self::Key => "ADDITIONAL_COLUMN_TYPE_KEY",
946 Self::Timestamp => "ADDITIONAL_COLUMN_TYPE_TIMESTAMP",
947 Self::Partition => "ADDITIONAL_COLUMN_TYPE_PARTITION",
948 Self::Offset => "ADDITIONAL_COLUMN_TYPE_OFFSET",
949 Self::Header => "ADDITIONAL_COLUMN_TYPE_HEADER",
950 Self::Filename => "ADDITIONAL_COLUMN_TYPE_FILENAME",
951 Self::Normal => "ADDITIONAL_COLUMN_TYPE_NORMAL",
952 Self::Payload => "ADDITIONAL_COLUMN_TYPE_PAYLOAD",
953 };
954 serializer.serialize_str(variant)
955 }
956}
957impl<'de> serde::Deserialize<'de> for AdditionalColumnType {
958 #[allow(deprecated)]
959 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
960 where
961 D: serde::Deserializer<'de>,
962 {
963 const FIELDS: &[&str] = &[
964 "ADDITIONAL_COLUMN_TYPE_UNSPECIFIED",
965 "ADDITIONAL_COLUMN_TYPE_KEY",
966 "ADDITIONAL_COLUMN_TYPE_TIMESTAMP",
967 "ADDITIONAL_COLUMN_TYPE_PARTITION",
968 "ADDITIONAL_COLUMN_TYPE_OFFSET",
969 "ADDITIONAL_COLUMN_TYPE_HEADER",
970 "ADDITIONAL_COLUMN_TYPE_FILENAME",
971 "ADDITIONAL_COLUMN_TYPE_NORMAL",
972 "ADDITIONAL_COLUMN_TYPE_PAYLOAD",
973 ];
974
975 struct GeneratedVisitor;
976
977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
978 type Value = AdditionalColumnType;
979
980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
981 write!(formatter, "expected one of: {:?}", &FIELDS)
982 }
983
984 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
985 where
986 E: serde::de::Error,
987 {
988 i32::try_from(v)
989 .ok()
990 .and_then(|x| x.try_into().ok())
991 .ok_or_else(|| {
992 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
993 })
994 }
995
996 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
997 where
998 E: serde::de::Error,
999 {
1000 i32::try_from(v)
1001 .ok()
1002 .and_then(|x| x.try_into().ok())
1003 .ok_or_else(|| {
1004 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1005 })
1006 }
1007
1008 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1009 where
1010 E: serde::de::Error,
1011 {
1012 match value {
1013 "ADDITIONAL_COLUMN_TYPE_UNSPECIFIED" => Ok(AdditionalColumnType::Unspecified),
1014 "ADDITIONAL_COLUMN_TYPE_KEY" => Ok(AdditionalColumnType::Key),
1015 "ADDITIONAL_COLUMN_TYPE_TIMESTAMP" => Ok(AdditionalColumnType::Timestamp),
1016 "ADDITIONAL_COLUMN_TYPE_PARTITION" => Ok(AdditionalColumnType::Partition),
1017 "ADDITIONAL_COLUMN_TYPE_OFFSET" => Ok(AdditionalColumnType::Offset),
1018 "ADDITIONAL_COLUMN_TYPE_HEADER" => Ok(AdditionalColumnType::Header),
1019 "ADDITIONAL_COLUMN_TYPE_FILENAME" => Ok(AdditionalColumnType::Filename),
1020 "ADDITIONAL_COLUMN_TYPE_NORMAL" => Ok(AdditionalColumnType::Normal),
1021 "ADDITIONAL_COLUMN_TYPE_PAYLOAD" => Ok(AdditionalColumnType::Payload),
1022 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1023 }
1024 }
1025 }
1026 deserializer.deserialize_any(GeneratedVisitor)
1027 }
1028}
1029impl serde::Serialize for AdditionalDatabaseName {
1030 #[allow(deprecated)]
1031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1032 where
1033 S: serde::Serializer,
1034 {
1035 use serde::ser::SerializeStruct;
1036 let len = 0;
1037 let struct_ser = serializer.serialize_struct("plan_common.AdditionalDatabaseName", len)?;
1038 struct_ser.end()
1039 }
1040}
1041impl<'de> serde::Deserialize<'de> for AdditionalDatabaseName {
1042 #[allow(deprecated)]
1043 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1044 where
1045 D: serde::Deserializer<'de>,
1046 {
1047 const FIELDS: &[&str] = &[
1048 ];
1049
1050 #[allow(clippy::enum_variant_names)]
1051 enum GeneratedField {
1052 }
1053 impl<'de> serde::Deserialize<'de> for GeneratedField {
1054 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1055 where
1056 D: serde::Deserializer<'de>,
1057 {
1058 struct GeneratedVisitor;
1059
1060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1061 type Value = GeneratedField;
1062
1063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1064 write!(formatter, "expected one of: {:?}", &FIELDS)
1065 }
1066
1067 #[allow(unused_variables)]
1068 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1069 where
1070 E: serde::de::Error,
1071 {
1072 Err(serde::de::Error::unknown_field(value, FIELDS))
1073 }
1074 }
1075 deserializer.deserialize_identifier(GeneratedVisitor)
1076 }
1077 }
1078 struct GeneratedVisitor;
1079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1080 type Value = AdditionalDatabaseName;
1081
1082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1083 formatter.write_str("struct plan_common.AdditionalDatabaseName")
1084 }
1085
1086 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalDatabaseName, V::Error>
1087 where
1088 V: serde::de::MapAccess<'de>,
1089 {
1090 while map_.next_key::<GeneratedField>()?.is_some() {
1091 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1092 }
1093 Ok(AdditionalDatabaseName {
1094 })
1095 }
1096 }
1097 deserializer.deserialize_struct("plan_common.AdditionalDatabaseName", FIELDS, GeneratedVisitor)
1098 }
1099}
1100impl serde::Serialize for AdditionalSchemaName {
1101 #[allow(deprecated)]
1102 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1103 where
1104 S: serde::Serializer,
1105 {
1106 use serde::ser::SerializeStruct;
1107 let len = 0;
1108 let struct_ser = serializer.serialize_struct("plan_common.AdditionalSchemaName", len)?;
1109 struct_ser.end()
1110 }
1111}
1112impl<'de> serde::Deserialize<'de> for AdditionalSchemaName {
1113 #[allow(deprecated)]
1114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1115 where
1116 D: serde::Deserializer<'de>,
1117 {
1118 const FIELDS: &[&str] = &[
1119 ];
1120
1121 #[allow(clippy::enum_variant_names)]
1122 enum GeneratedField {
1123 }
1124 impl<'de> serde::Deserialize<'de> for GeneratedField {
1125 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1126 where
1127 D: serde::Deserializer<'de>,
1128 {
1129 struct GeneratedVisitor;
1130
1131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1132 type Value = GeneratedField;
1133
1134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1135 write!(formatter, "expected one of: {:?}", &FIELDS)
1136 }
1137
1138 #[allow(unused_variables)]
1139 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1140 where
1141 E: serde::de::Error,
1142 {
1143 Err(serde::de::Error::unknown_field(value, FIELDS))
1144 }
1145 }
1146 deserializer.deserialize_identifier(GeneratedVisitor)
1147 }
1148 }
1149 struct GeneratedVisitor;
1150 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1151 type Value = AdditionalSchemaName;
1152
1153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1154 formatter.write_str("struct plan_common.AdditionalSchemaName")
1155 }
1156
1157 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalSchemaName, V::Error>
1158 where
1159 V: serde::de::MapAccess<'de>,
1160 {
1161 while map_.next_key::<GeneratedField>()?.is_some() {
1162 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1163 }
1164 Ok(AdditionalSchemaName {
1165 })
1166 }
1167 }
1168 deserializer.deserialize_struct("plan_common.AdditionalSchemaName", FIELDS, GeneratedVisitor)
1169 }
1170}
1171impl serde::Serialize for AdditionalSubject {
1172 #[allow(deprecated)]
1173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1174 where
1175 S: serde::Serializer,
1176 {
1177 use serde::ser::SerializeStruct;
1178 let len = 0;
1179 let struct_ser = serializer.serialize_struct("plan_common.AdditionalSubject", len)?;
1180 struct_ser.end()
1181 }
1182}
1183impl<'de> serde::Deserialize<'de> for AdditionalSubject {
1184 #[allow(deprecated)]
1185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1186 where
1187 D: serde::Deserializer<'de>,
1188 {
1189 const FIELDS: &[&str] = &[
1190 ];
1191
1192 #[allow(clippy::enum_variant_names)]
1193 enum GeneratedField {
1194 }
1195 impl<'de> serde::Deserialize<'de> for GeneratedField {
1196 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1197 where
1198 D: serde::Deserializer<'de>,
1199 {
1200 struct GeneratedVisitor;
1201
1202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1203 type Value = GeneratedField;
1204
1205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1206 write!(formatter, "expected one of: {:?}", &FIELDS)
1207 }
1208
1209 #[allow(unused_variables)]
1210 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1211 where
1212 E: serde::de::Error,
1213 {
1214 Err(serde::de::Error::unknown_field(value, FIELDS))
1215 }
1216 }
1217 deserializer.deserialize_identifier(GeneratedVisitor)
1218 }
1219 }
1220 struct GeneratedVisitor;
1221 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1222 type Value = AdditionalSubject;
1223
1224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1225 formatter.write_str("struct plan_common.AdditionalSubject")
1226 }
1227
1228 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalSubject, V::Error>
1229 where
1230 V: serde::de::MapAccess<'de>,
1231 {
1232 while map_.next_key::<GeneratedField>()?.is_some() {
1233 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1234 }
1235 Ok(AdditionalSubject {
1236 })
1237 }
1238 }
1239 deserializer.deserialize_struct("plan_common.AdditionalSubject", FIELDS, GeneratedVisitor)
1240 }
1241}
1242impl serde::Serialize for AdditionalTableName {
1243 #[allow(deprecated)]
1244 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1245 where
1246 S: serde::Serializer,
1247 {
1248 use serde::ser::SerializeStruct;
1249 let len = 0;
1250 let struct_ser = serializer.serialize_struct("plan_common.AdditionalTableName", len)?;
1251 struct_ser.end()
1252 }
1253}
1254impl<'de> serde::Deserialize<'de> for AdditionalTableName {
1255 #[allow(deprecated)]
1256 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1257 where
1258 D: serde::Deserializer<'de>,
1259 {
1260 const FIELDS: &[&str] = &[
1261 ];
1262
1263 #[allow(clippy::enum_variant_names)]
1264 enum GeneratedField {
1265 }
1266 impl<'de> serde::Deserialize<'de> for GeneratedField {
1267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1268 where
1269 D: serde::Deserializer<'de>,
1270 {
1271 struct GeneratedVisitor;
1272
1273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1274 type Value = GeneratedField;
1275
1276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1277 write!(formatter, "expected one of: {:?}", &FIELDS)
1278 }
1279
1280 #[allow(unused_variables)]
1281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1282 where
1283 E: serde::de::Error,
1284 {
1285 Err(serde::de::Error::unknown_field(value, FIELDS))
1286 }
1287 }
1288 deserializer.deserialize_identifier(GeneratedVisitor)
1289 }
1290 }
1291 struct GeneratedVisitor;
1292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1293 type Value = AdditionalTableName;
1294
1295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1296 formatter.write_str("struct plan_common.AdditionalTableName")
1297 }
1298
1299 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AdditionalTableName, V::Error>
1300 where
1301 V: serde::de::MapAccess<'de>,
1302 {
1303 while map_.next_key::<GeneratedField>()?.is_some() {
1304 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1305 }
1306 Ok(AdditionalTableName {
1307 })
1308 }
1309 }
1310 deserializer.deserialize_struct("plan_common.AdditionalTableName", FIELDS, GeneratedVisitor)
1311 }
1312}
1313impl serde::Serialize for AsOfJoinDesc {
1314 #[allow(deprecated)]
1315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1316 where
1317 S: serde::Serializer,
1318 {
1319 use serde::ser::SerializeStruct;
1320 let mut len = 0;
1321 if self.right_idx != 0 {
1322 len += 1;
1323 }
1324 if self.left_idx != 0 {
1325 len += 1;
1326 }
1327 if self.inequality_type != 0 {
1328 len += 1;
1329 }
1330 let mut struct_ser = serializer.serialize_struct("plan_common.AsOfJoinDesc", len)?;
1331 if self.right_idx != 0 {
1332 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
1333 }
1334 if self.left_idx != 0 {
1335 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
1336 }
1337 if self.inequality_type != 0 {
1338 let v = AsOfJoinInequalityType::try_from(self.inequality_type)
1339 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.inequality_type)))?;
1340 struct_ser.serialize_field("inequalityType", &v)?;
1341 }
1342 struct_ser.end()
1343 }
1344}
1345impl<'de> serde::Deserialize<'de> for AsOfJoinDesc {
1346 #[allow(deprecated)]
1347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1348 where
1349 D: serde::Deserializer<'de>,
1350 {
1351 const FIELDS: &[&str] = &[
1352 "right_idx",
1353 "rightIdx",
1354 "left_idx",
1355 "leftIdx",
1356 "inequality_type",
1357 "inequalityType",
1358 ];
1359
1360 #[allow(clippy::enum_variant_names)]
1361 enum GeneratedField {
1362 RightIdx,
1363 LeftIdx,
1364 InequalityType,
1365 }
1366 impl<'de> serde::Deserialize<'de> for GeneratedField {
1367 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1368 where
1369 D: serde::Deserializer<'de>,
1370 {
1371 struct GeneratedVisitor;
1372
1373 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1374 type Value = GeneratedField;
1375
1376 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1377 write!(formatter, "expected one of: {:?}", &FIELDS)
1378 }
1379
1380 #[allow(unused_variables)]
1381 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1382 where
1383 E: serde::de::Error,
1384 {
1385 match value {
1386 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
1387 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
1388 "inequalityType" | "inequality_type" => Ok(GeneratedField::InequalityType),
1389 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1390 }
1391 }
1392 }
1393 deserializer.deserialize_identifier(GeneratedVisitor)
1394 }
1395 }
1396 struct GeneratedVisitor;
1397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1398 type Value = AsOfJoinDesc;
1399
1400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1401 formatter.write_str("struct plan_common.AsOfJoinDesc")
1402 }
1403
1404 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinDesc, V::Error>
1405 where
1406 V: serde::de::MapAccess<'de>,
1407 {
1408 let mut right_idx__ = None;
1409 let mut left_idx__ = None;
1410 let mut inequality_type__ = None;
1411 while let Some(k) = map_.next_key()? {
1412 match k {
1413 GeneratedField::RightIdx => {
1414 if right_idx__.is_some() {
1415 return Err(serde::de::Error::duplicate_field("rightIdx"));
1416 }
1417 right_idx__ =
1418 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1419 ;
1420 }
1421 GeneratedField::LeftIdx => {
1422 if left_idx__.is_some() {
1423 return Err(serde::de::Error::duplicate_field("leftIdx"));
1424 }
1425 left_idx__ =
1426 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1427 ;
1428 }
1429 GeneratedField::InequalityType => {
1430 if inequality_type__.is_some() {
1431 return Err(serde::de::Error::duplicate_field("inequalityType"));
1432 }
1433 inequality_type__ = Some(map_.next_value::<AsOfJoinInequalityType>()? as i32);
1434 }
1435 }
1436 }
1437 Ok(AsOfJoinDesc {
1438 right_idx: right_idx__.unwrap_or_default(),
1439 left_idx: left_idx__.unwrap_or_default(),
1440 inequality_type: inequality_type__.unwrap_or_default(),
1441 })
1442 }
1443 }
1444 deserializer.deserialize_struct("plan_common.AsOfJoinDesc", FIELDS, GeneratedVisitor)
1445 }
1446}
1447impl serde::Serialize for AsOfJoinInequalityType {
1448 #[allow(deprecated)]
1449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1450 where
1451 S: serde::Serializer,
1452 {
1453 let variant = match self {
1454 Self::AsOfInequalityTypeUnspecified => "AS_OF_INEQUALITY_TYPE_UNSPECIFIED",
1455 Self::AsOfInequalityTypeGt => "AS_OF_INEQUALITY_TYPE_GT",
1456 Self::AsOfInequalityTypeGe => "AS_OF_INEQUALITY_TYPE_GE",
1457 Self::AsOfInequalityTypeLt => "AS_OF_INEQUALITY_TYPE_LT",
1458 Self::AsOfInequalityTypeLe => "AS_OF_INEQUALITY_TYPE_LE",
1459 };
1460 serializer.serialize_str(variant)
1461 }
1462}
1463impl<'de> serde::Deserialize<'de> for AsOfJoinInequalityType {
1464 #[allow(deprecated)]
1465 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1466 where
1467 D: serde::Deserializer<'de>,
1468 {
1469 const FIELDS: &[&str] = &[
1470 "AS_OF_INEQUALITY_TYPE_UNSPECIFIED",
1471 "AS_OF_INEQUALITY_TYPE_GT",
1472 "AS_OF_INEQUALITY_TYPE_GE",
1473 "AS_OF_INEQUALITY_TYPE_LT",
1474 "AS_OF_INEQUALITY_TYPE_LE",
1475 ];
1476
1477 struct GeneratedVisitor;
1478
1479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1480 type Value = AsOfJoinInequalityType;
1481
1482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1483 write!(formatter, "expected one of: {:?}", &FIELDS)
1484 }
1485
1486 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1487 where
1488 E: serde::de::Error,
1489 {
1490 i32::try_from(v)
1491 .ok()
1492 .and_then(|x| x.try_into().ok())
1493 .ok_or_else(|| {
1494 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1495 })
1496 }
1497
1498 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1499 where
1500 E: serde::de::Error,
1501 {
1502 i32::try_from(v)
1503 .ok()
1504 .and_then(|x| x.try_into().ok())
1505 .ok_or_else(|| {
1506 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1507 })
1508 }
1509
1510 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1511 where
1512 E: serde::de::Error,
1513 {
1514 match value {
1515 "AS_OF_INEQUALITY_TYPE_UNSPECIFIED" => Ok(AsOfJoinInequalityType::AsOfInequalityTypeUnspecified),
1516 "AS_OF_INEQUALITY_TYPE_GT" => Ok(AsOfJoinInequalityType::AsOfInequalityTypeGt),
1517 "AS_OF_INEQUALITY_TYPE_GE" => Ok(AsOfJoinInequalityType::AsOfInequalityTypeGe),
1518 "AS_OF_INEQUALITY_TYPE_LT" => Ok(AsOfJoinInequalityType::AsOfInequalityTypeLt),
1519 "AS_OF_INEQUALITY_TYPE_LE" => Ok(AsOfJoinInequalityType::AsOfInequalityTypeLe),
1520 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1521 }
1522 }
1523 }
1524 deserializer.deserialize_any(GeneratedVisitor)
1525 }
1526}
1527impl serde::Serialize for AsOfJoinType {
1528 #[allow(deprecated)]
1529 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1530 where
1531 S: serde::Serializer,
1532 {
1533 let variant = match self {
1534 Self::Unspecified => "AS_OF_JOIN_TYPE_UNSPECIFIED",
1535 Self::Inner => "AS_OF_JOIN_TYPE_INNER",
1536 Self::LeftOuter => "AS_OF_JOIN_TYPE_LEFT_OUTER",
1537 };
1538 serializer.serialize_str(variant)
1539 }
1540}
1541impl<'de> serde::Deserialize<'de> for AsOfJoinType {
1542 #[allow(deprecated)]
1543 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1544 where
1545 D: serde::Deserializer<'de>,
1546 {
1547 const FIELDS: &[&str] = &[
1548 "AS_OF_JOIN_TYPE_UNSPECIFIED",
1549 "AS_OF_JOIN_TYPE_INNER",
1550 "AS_OF_JOIN_TYPE_LEFT_OUTER",
1551 ];
1552
1553 struct GeneratedVisitor;
1554
1555 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1556 type Value = AsOfJoinType;
1557
1558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1559 write!(formatter, "expected one of: {:?}", &FIELDS)
1560 }
1561
1562 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1563 where
1564 E: serde::de::Error,
1565 {
1566 i32::try_from(v)
1567 .ok()
1568 .and_then(|x| x.try_into().ok())
1569 .ok_or_else(|| {
1570 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1571 })
1572 }
1573
1574 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1575 where
1576 E: serde::de::Error,
1577 {
1578 i32::try_from(v)
1579 .ok()
1580 .and_then(|x| x.try_into().ok())
1581 .ok_or_else(|| {
1582 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1583 })
1584 }
1585
1586 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1587 where
1588 E: serde::de::Error,
1589 {
1590 match value {
1591 "AS_OF_JOIN_TYPE_UNSPECIFIED" => Ok(AsOfJoinType::Unspecified),
1592 "AS_OF_JOIN_TYPE_INNER" => Ok(AsOfJoinType::Inner),
1593 "AS_OF_JOIN_TYPE_LEFT_OUTER" => Ok(AsOfJoinType::LeftOuter),
1594 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1595 }
1596 }
1597 }
1598 deserializer.deserialize_any(GeneratedVisitor)
1599 }
1600}
1601impl serde::Serialize for Cardinality {
1602 #[allow(deprecated)]
1603 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1604 where
1605 S: serde::Serializer,
1606 {
1607 use serde::ser::SerializeStruct;
1608 let mut len = 0;
1609 if self.lo != 0 {
1610 len += 1;
1611 }
1612 if self.hi.is_some() {
1613 len += 1;
1614 }
1615 let mut struct_ser = serializer.serialize_struct("plan_common.Cardinality", len)?;
1616 if self.lo != 0 {
1617 #[allow(clippy::needless_borrow)]
1618 #[allow(clippy::needless_borrows_for_generic_args)]
1619 struct_ser.serialize_field("lo", ToString::to_string(&self.lo).as_str())?;
1620 }
1621 if let Some(v) = self.hi.as_ref() {
1622 #[allow(clippy::needless_borrow)]
1623 #[allow(clippy::needless_borrows_for_generic_args)]
1624 struct_ser.serialize_field("hi", ToString::to_string(&v).as_str())?;
1625 }
1626 struct_ser.end()
1627 }
1628}
1629impl<'de> serde::Deserialize<'de> for Cardinality {
1630 #[allow(deprecated)]
1631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1632 where
1633 D: serde::Deserializer<'de>,
1634 {
1635 const FIELDS: &[&str] = &[
1636 "lo",
1637 "hi",
1638 ];
1639
1640 #[allow(clippy::enum_variant_names)]
1641 enum GeneratedField {
1642 Lo,
1643 Hi,
1644 }
1645 impl<'de> serde::Deserialize<'de> for GeneratedField {
1646 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1647 where
1648 D: serde::Deserializer<'de>,
1649 {
1650 struct GeneratedVisitor;
1651
1652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1653 type Value = GeneratedField;
1654
1655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1656 write!(formatter, "expected one of: {:?}", &FIELDS)
1657 }
1658
1659 #[allow(unused_variables)]
1660 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1661 where
1662 E: serde::de::Error,
1663 {
1664 match value {
1665 "lo" => Ok(GeneratedField::Lo),
1666 "hi" => Ok(GeneratedField::Hi),
1667 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1668 }
1669 }
1670 }
1671 deserializer.deserialize_identifier(GeneratedVisitor)
1672 }
1673 }
1674 struct GeneratedVisitor;
1675 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1676 type Value = Cardinality;
1677
1678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1679 formatter.write_str("struct plan_common.Cardinality")
1680 }
1681
1682 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Cardinality, V::Error>
1683 where
1684 V: serde::de::MapAccess<'de>,
1685 {
1686 let mut lo__ = None;
1687 let mut hi__ = None;
1688 while let Some(k) = map_.next_key()? {
1689 match k {
1690 GeneratedField::Lo => {
1691 if lo__.is_some() {
1692 return Err(serde::de::Error::duplicate_field("lo"));
1693 }
1694 lo__ =
1695 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1696 ;
1697 }
1698 GeneratedField::Hi => {
1699 if hi__.is_some() {
1700 return Err(serde::de::Error::duplicate_field("hi"));
1701 }
1702 hi__ =
1703 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1704 ;
1705 }
1706 }
1707 }
1708 Ok(Cardinality {
1709 lo: lo__.unwrap_or_default(),
1710 hi: hi__,
1711 })
1712 }
1713 }
1714 deserializer.deserialize_struct("plan_common.Cardinality", FIELDS, GeneratedVisitor)
1715 }
1716}
1717impl serde::Serialize for ColumnCatalog {
1718 #[allow(deprecated)]
1719 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1720 where
1721 S: serde::Serializer,
1722 {
1723 use serde::ser::SerializeStruct;
1724 let mut len = 0;
1725 if self.column_desc.is_some() {
1726 len += 1;
1727 }
1728 if self.is_hidden {
1729 len += 1;
1730 }
1731 let mut struct_ser = serializer.serialize_struct("plan_common.ColumnCatalog", len)?;
1732 if let Some(v) = self.column_desc.as_ref() {
1733 struct_ser.serialize_field("columnDesc", v)?;
1734 }
1735 if self.is_hidden {
1736 struct_ser.serialize_field("isHidden", &self.is_hidden)?;
1737 }
1738 struct_ser.end()
1739 }
1740}
1741impl<'de> serde::Deserialize<'de> for ColumnCatalog {
1742 #[allow(deprecated)]
1743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1744 where
1745 D: serde::Deserializer<'de>,
1746 {
1747 const FIELDS: &[&str] = &[
1748 "column_desc",
1749 "columnDesc",
1750 "is_hidden",
1751 "isHidden",
1752 ];
1753
1754 #[allow(clippy::enum_variant_names)]
1755 enum GeneratedField {
1756 ColumnDesc,
1757 IsHidden,
1758 }
1759 impl<'de> serde::Deserialize<'de> for GeneratedField {
1760 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1761 where
1762 D: serde::Deserializer<'de>,
1763 {
1764 struct GeneratedVisitor;
1765
1766 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1767 type Value = GeneratedField;
1768
1769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1770 write!(formatter, "expected one of: {:?}", &FIELDS)
1771 }
1772
1773 #[allow(unused_variables)]
1774 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1775 where
1776 E: serde::de::Error,
1777 {
1778 match value {
1779 "columnDesc" | "column_desc" => Ok(GeneratedField::ColumnDesc),
1780 "isHidden" | "is_hidden" => Ok(GeneratedField::IsHidden),
1781 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1782 }
1783 }
1784 }
1785 deserializer.deserialize_identifier(GeneratedVisitor)
1786 }
1787 }
1788 struct GeneratedVisitor;
1789 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1790 type Value = ColumnCatalog;
1791
1792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1793 formatter.write_str("struct plan_common.ColumnCatalog")
1794 }
1795
1796 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ColumnCatalog, V::Error>
1797 where
1798 V: serde::de::MapAccess<'de>,
1799 {
1800 let mut column_desc__ = None;
1801 let mut is_hidden__ = None;
1802 while let Some(k) = map_.next_key()? {
1803 match k {
1804 GeneratedField::ColumnDesc => {
1805 if column_desc__.is_some() {
1806 return Err(serde::de::Error::duplicate_field("columnDesc"));
1807 }
1808 column_desc__ = map_.next_value()?;
1809 }
1810 GeneratedField::IsHidden => {
1811 if is_hidden__.is_some() {
1812 return Err(serde::de::Error::duplicate_field("isHidden"));
1813 }
1814 is_hidden__ = Some(map_.next_value()?);
1815 }
1816 }
1817 }
1818 Ok(ColumnCatalog {
1819 column_desc: column_desc__,
1820 is_hidden: is_hidden__.unwrap_or_default(),
1821 })
1822 }
1823 }
1824 deserializer.deserialize_struct("plan_common.ColumnCatalog", FIELDS, GeneratedVisitor)
1825 }
1826}
1827impl serde::Serialize for ColumnDesc {
1828 #[allow(deprecated)]
1829 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1830 where
1831 S: serde::Serializer,
1832 {
1833 use serde::ser::SerializeStruct;
1834 let mut len = 0;
1835 if self.column_type.is_some() {
1836 len += 1;
1837 }
1838 if self.column_id != 0 {
1839 len += 1;
1840 }
1841 if !self.name.is_empty() {
1842 len += 1;
1843 }
1844 if self.description.is_some() {
1845 len += 1;
1846 }
1847 if self.additional_column_type != 0 {
1848 len += 1;
1849 }
1850 if self.version != 0 {
1851 len += 1;
1852 }
1853 if self.additional_column.is_some() {
1854 len += 1;
1855 }
1856 if self.nullable.is_some() {
1857 len += 1;
1858 }
1859 if self.generated_or_default_column.is_some() {
1860 len += 1;
1861 }
1862 let mut struct_ser = serializer.serialize_struct("plan_common.ColumnDesc", len)?;
1863 if let Some(v) = self.column_type.as_ref() {
1864 struct_ser.serialize_field("columnType", v)?;
1865 }
1866 if self.column_id != 0 {
1867 struct_ser.serialize_field("columnId", &self.column_id)?;
1868 }
1869 if !self.name.is_empty() {
1870 struct_ser.serialize_field("name", &self.name)?;
1871 }
1872 if let Some(v) = self.description.as_ref() {
1873 struct_ser.serialize_field("description", v)?;
1874 }
1875 if self.additional_column_type != 0 {
1876 let v = AdditionalColumnType::try_from(self.additional_column_type)
1877 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.additional_column_type)))?;
1878 struct_ser.serialize_field("additionalColumnType", &v)?;
1879 }
1880 if self.version != 0 {
1881 let v = ColumnDescVersion::try_from(self.version)
1882 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
1883 struct_ser.serialize_field("version", &v)?;
1884 }
1885 if let Some(v) = self.additional_column.as_ref() {
1886 struct_ser.serialize_field("additionalColumn", v)?;
1887 }
1888 if let Some(v) = self.nullable.as_ref() {
1889 struct_ser.serialize_field("nullable", v)?;
1890 }
1891 if let Some(v) = self.generated_or_default_column.as_ref() {
1892 match v {
1893 column_desc::GeneratedOrDefaultColumn::GeneratedColumn(v) => {
1894 struct_ser.serialize_field("generatedColumn", v)?;
1895 }
1896 column_desc::GeneratedOrDefaultColumn::DefaultColumn(v) => {
1897 struct_ser.serialize_field("defaultColumn", v)?;
1898 }
1899 }
1900 }
1901 struct_ser.end()
1902 }
1903}
1904impl<'de> serde::Deserialize<'de> for ColumnDesc {
1905 #[allow(deprecated)]
1906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1907 where
1908 D: serde::Deserializer<'de>,
1909 {
1910 const FIELDS: &[&str] = &[
1911 "column_type",
1912 "columnType",
1913 "column_id",
1914 "columnId",
1915 "name",
1916 "description",
1917 "additional_column_type",
1918 "additionalColumnType",
1919 "version",
1920 "additional_column",
1921 "additionalColumn",
1922 "nullable",
1923 "generated_column",
1924 "generatedColumn",
1925 "default_column",
1926 "defaultColumn",
1927 ];
1928
1929 #[allow(clippy::enum_variant_names)]
1930 enum GeneratedField {
1931 ColumnType,
1932 ColumnId,
1933 Name,
1934 Description,
1935 AdditionalColumnType,
1936 Version,
1937 AdditionalColumn,
1938 Nullable,
1939 GeneratedColumn,
1940 DefaultColumn,
1941 }
1942 impl<'de> serde::Deserialize<'de> for GeneratedField {
1943 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1944 where
1945 D: serde::Deserializer<'de>,
1946 {
1947 struct GeneratedVisitor;
1948
1949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1950 type Value = GeneratedField;
1951
1952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1953 write!(formatter, "expected one of: {:?}", &FIELDS)
1954 }
1955
1956 #[allow(unused_variables)]
1957 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1958 where
1959 E: serde::de::Error,
1960 {
1961 match value {
1962 "columnType" | "column_type" => Ok(GeneratedField::ColumnType),
1963 "columnId" | "column_id" => Ok(GeneratedField::ColumnId),
1964 "name" => Ok(GeneratedField::Name),
1965 "description" => Ok(GeneratedField::Description),
1966 "additionalColumnType" | "additional_column_type" => Ok(GeneratedField::AdditionalColumnType),
1967 "version" => Ok(GeneratedField::Version),
1968 "additionalColumn" | "additional_column" => Ok(GeneratedField::AdditionalColumn),
1969 "nullable" => Ok(GeneratedField::Nullable),
1970 "generatedColumn" | "generated_column" => Ok(GeneratedField::GeneratedColumn),
1971 "defaultColumn" | "default_column" => Ok(GeneratedField::DefaultColumn),
1972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1973 }
1974 }
1975 }
1976 deserializer.deserialize_identifier(GeneratedVisitor)
1977 }
1978 }
1979 struct GeneratedVisitor;
1980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1981 type Value = ColumnDesc;
1982
1983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1984 formatter.write_str("struct plan_common.ColumnDesc")
1985 }
1986
1987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ColumnDesc, V::Error>
1988 where
1989 V: serde::de::MapAccess<'de>,
1990 {
1991 let mut column_type__ = None;
1992 let mut column_id__ = None;
1993 let mut name__ = None;
1994 let mut description__ = None;
1995 let mut additional_column_type__ = None;
1996 let mut version__ = None;
1997 let mut additional_column__ = None;
1998 let mut nullable__ = None;
1999 let mut generated_or_default_column__ = None;
2000 while let Some(k) = map_.next_key()? {
2001 match k {
2002 GeneratedField::ColumnType => {
2003 if column_type__.is_some() {
2004 return Err(serde::de::Error::duplicate_field("columnType"));
2005 }
2006 column_type__ = map_.next_value()?;
2007 }
2008 GeneratedField::ColumnId => {
2009 if column_id__.is_some() {
2010 return Err(serde::de::Error::duplicate_field("columnId"));
2011 }
2012 column_id__ =
2013 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2014 ;
2015 }
2016 GeneratedField::Name => {
2017 if name__.is_some() {
2018 return Err(serde::de::Error::duplicate_field("name"));
2019 }
2020 name__ = Some(map_.next_value()?);
2021 }
2022 GeneratedField::Description => {
2023 if description__.is_some() {
2024 return Err(serde::de::Error::duplicate_field("description"));
2025 }
2026 description__ = map_.next_value()?;
2027 }
2028 GeneratedField::AdditionalColumnType => {
2029 if additional_column_type__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("additionalColumnType"));
2031 }
2032 additional_column_type__ = Some(map_.next_value::<AdditionalColumnType>()? as i32);
2033 }
2034 GeneratedField::Version => {
2035 if version__.is_some() {
2036 return Err(serde::de::Error::duplicate_field("version"));
2037 }
2038 version__ = Some(map_.next_value::<ColumnDescVersion>()? as i32);
2039 }
2040 GeneratedField::AdditionalColumn => {
2041 if additional_column__.is_some() {
2042 return Err(serde::de::Error::duplicate_field("additionalColumn"));
2043 }
2044 additional_column__ = map_.next_value()?;
2045 }
2046 GeneratedField::Nullable => {
2047 if nullable__.is_some() {
2048 return Err(serde::de::Error::duplicate_field("nullable"));
2049 }
2050 nullable__ = map_.next_value()?;
2051 }
2052 GeneratedField::GeneratedColumn => {
2053 if generated_or_default_column__.is_some() {
2054 return Err(serde::de::Error::duplicate_field("generatedColumn"));
2055 }
2056 generated_or_default_column__ = map_.next_value::<::std::option::Option<_>>()?.map(column_desc::GeneratedOrDefaultColumn::GeneratedColumn)
2057;
2058 }
2059 GeneratedField::DefaultColumn => {
2060 if generated_or_default_column__.is_some() {
2061 return Err(serde::de::Error::duplicate_field("defaultColumn"));
2062 }
2063 generated_or_default_column__ = map_.next_value::<::std::option::Option<_>>()?.map(column_desc::GeneratedOrDefaultColumn::DefaultColumn)
2064;
2065 }
2066 }
2067 }
2068 Ok(ColumnDesc {
2069 column_type: column_type__,
2070 column_id: column_id__.unwrap_or_default(),
2071 name: name__.unwrap_or_default(),
2072 description: description__,
2073 additional_column_type: additional_column_type__.unwrap_or_default(),
2074 version: version__.unwrap_or_default(),
2075 additional_column: additional_column__,
2076 nullable: nullable__,
2077 generated_or_default_column: generated_or_default_column__,
2078 })
2079 }
2080 }
2081 deserializer.deserialize_struct("plan_common.ColumnDesc", FIELDS, GeneratedVisitor)
2082 }
2083}
2084impl serde::Serialize for ColumnDescVersion {
2085 #[allow(deprecated)]
2086 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2087 where
2088 S: serde::Serializer,
2089 {
2090 let variant = match self {
2091 Self::Unspecified => "COLUMN_DESC_VERSION_UNSPECIFIED",
2092 Self::Pr13707 => "COLUMN_DESC_VERSION_PR_13707",
2093 };
2094 serializer.serialize_str(variant)
2095 }
2096}
2097impl<'de> serde::Deserialize<'de> for ColumnDescVersion {
2098 #[allow(deprecated)]
2099 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2100 where
2101 D: serde::Deserializer<'de>,
2102 {
2103 const FIELDS: &[&str] = &[
2104 "COLUMN_DESC_VERSION_UNSPECIFIED",
2105 "COLUMN_DESC_VERSION_PR_13707",
2106 ];
2107
2108 struct GeneratedVisitor;
2109
2110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2111 type Value = ColumnDescVersion;
2112
2113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2114 write!(formatter, "expected one of: {:?}", &FIELDS)
2115 }
2116
2117 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2118 where
2119 E: serde::de::Error,
2120 {
2121 i32::try_from(v)
2122 .ok()
2123 .and_then(|x| x.try_into().ok())
2124 .ok_or_else(|| {
2125 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2126 })
2127 }
2128
2129 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2130 where
2131 E: serde::de::Error,
2132 {
2133 i32::try_from(v)
2134 .ok()
2135 .and_then(|x| x.try_into().ok())
2136 .ok_or_else(|| {
2137 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2138 })
2139 }
2140
2141 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2142 where
2143 E: serde::de::Error,
2144 {
2145 match value {
2146 "COLUMN_DESC_VERSION_UNSPECIFIED" => Ok(ColumnDescVersion::Unspecified),
2147 "COLUMN_DESC_VERSION_PR_13707" => Ok(ColumnDescVersion::Pr13707),
2148 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2149 }
2150 }
2151 }
2152 deserializer.deserialize_any(GeneratedVisitor)
2153 }
2154}
2155impl serde::Serialize for DefaultColumnDesc {
2156 #[allow(deprecated)]
2157 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2158 where
2159 S: serde::Serializer,
2160 {
2161 use serde::ser::SerializeStruct;
2162 let mut len = 0;
2163 if self.expr.is_some() {
2164 len += 1;
2165 }
2166 if self.snapshot_value.is_some() {
2167 len += 1;
2168 }
2169 let mut struct_ser = serializer.serialize_struct("plan_common.DefaultColumnDesc", len)?;
2170 if let Some(v) = self.expr.as_ref() {
2171 struct_ser.serialize_field("expr", v)?;
2172 }
2173 if let Some(v) = self.snapshot_value.as_ref() {
2174 struct_ser.serialize_field("snapshotValue", v)?;
2175 }
2176 struct_ser.end()
2177 }
2178}
2179impl<'de> serde::Deserialize<'de> for DefaultColumnDesc {
2180 #[allow(deprecated)]
2181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2182 where
2183 D: serde::Deserializer<'de>,
2184 {
2185 const FIELDS: &[&str] = &[
2186 "expr",
2187 "snapshot_value",
2188 "snapshotValue",
2189 ];
2190
2191 #[allow(clippy::enum_variant_names)]
2192 enum GeneratedField {
2193 Expr,
2194 SnapshotValue,
2195 }
2196 impl<'de> serde::Deserialize<'de> for GeneratedField {
2197 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2198 where
2199 D: serde::Deserializer<'de>,
2200 {
2201 struct GeneratedVisitor;
2202
2203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2204 type Value = GeneratedField;
2205
2206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2207 write!(formatter, "expected one of: {:?}", &FIELDS)
2208 }
2209
2210 #[allow(unused_variables)]
2211 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2212 where
2213 E: serde::de::Error,
2214 {
2215 match value {
2216 "expr" => Ok(GeneratedField::Expr),
2217 "snapshotValue" | "snapshot_value" => Ok(GeneratedField::SnapshotValue),
2218 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2219 }
2220 }
2221 }
2222 deserializer.deserialize_identifier(GeneratedVisitor)
2223 }
2224 }
2225 struct GeneratedVisitor;
2226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2227 type Value = DefaultColumnDesc;
2228
2229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2230 formatter.write_str("struct plan_common.DefaultColumnDesc")
2231 }
2232
2233 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DefaultColumnDesc, V::Error>
2234 where
2235 V: serde::de::MapAccess<'de>,
2236 {
2237 let mut expr__ = None;
2238 let mut snapshot_value__ = None;
2239 while let Some(k) = map_.next_key()? {
2240 match k {
2241 GeneratedField::Expr => {
2242 if expr__.is_some() {
2243 return Err(serde::de::Error::duplicate_field("expr"));
2244 }
2245 expr__ = map_.next_value()?;
2246 }
2247 GeneratedField::SnapshotValue => {
2248 if snapshot_value__.is_some() {
2249 return Err(serde::de::Error::duplicate_field("snapshotValue"));
2250 }
2251 snapshot_value__ = map_.next_value()?;
2252 }
2253 }
2254 }
2255 Ok(DefaultColumnDesc {
2256 expr: expr__,
2257 snapshot_value: snapshot_value__,
2258 })
2259 }
2260 }
2261 deserializer.deserialize_struct("plan_common.DefaultColumnDesc", FIELDS, GeneratedVisitor)
2262 }
2263}
2264impl serde::Serialize for DefaultColumns {
2265 #[allow(deprecated)]
2266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2267 where
2268 S: serde::Serializer,
2269 {
2270 use serde::ser::SerializeStruct;
2271 let mut len = 0;
2272 if !self.default_columns.is_empty() {
2273 len += 1;
2274 }
2275 let mut struct_ser = serializer.serialize_struct("plan_common.DefaultColumns", len)?;
2276 if !self.default_columns.is_empty() {
2277 struct_ser.serialize_field("defaultColumns", &self.default_columns)?;
2278 }
2279 struct_ser.end()
2280 }
2281}
2282impl<'de> serde::Deserialize<'de> for DefaultColumns {
2283 #[allow(deprecated)]
2284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2285 where
2286 D: serde::Deserializer<'de>,
2287 {
2288 const FIELDS: &[&str] = &[
2289 "default_columns",
2290 "defaultColumns",
2291 ];
2292
2293 #[allow(clippy::enum_variant_names)]
2294 enum GeneratedField {
2295 DefaultColumns,
2296 }
2297 impl<'de> serde::Deserialize<'de> for GeneratedField {
2298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2299 where
2300 D: serde::Deserializer<'de>,
2301 {
2302 struct GeneratedVisitor;
2303
2304 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2305 type Value = GeneratedField;
2306
2307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2308 write!(formatter, "expected one of: {:?}", &FIELDS)
2309 }
2310
2311 #[allow(unused_variables)]
2312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2313 where
2314 E: serde::de::Error,
2315 {
2316 match value {
2317 "defaultColumns" | "default_columns" => Ok(GeneratedField::DefaultColumns),
2318 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2319 }
2320 }
2321 }
2322 deserializer.deserialize_identifier(GeneratedVisitor)
2323 }
2324 }
2325 struct GeneratedVisitor;
2326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2327 type Value = DefaultColumns;
2328
2329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2330 formatter.write_str("struct plan_common.DefaultColumns")
2331 }
2332
2333 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DefaultColumns, V::Error>
2334 where
2335 V: serde::de::MapAccess<'de>,
2336 {
2337 let mut default_columns__ = None;
2338 while let Some(k) = map_.next_key()? {
2339 match k {
2340 GeneratedField::DefaultColumns => {
2341 if default_columns__.is_some() {
2342 return Err(serde::de::Error::duplicate_field("defaultColumns"));
2343 }
2344 default_columns__ = Some(map_.next_value()?);
2345 }
2346 }
2347 }
2348 Ok(DefaultColumns {
2349 default_columns: default_columns__.unwrap_or_default(),
2350 })
2351 }
2352 }
2353 deserializer.deserialize_struct("plan_common.DefaultColumns", FIELDS, GeneratedVisitor)
2354 }
2355}
2356impl serde::Serialize for EncodeType {
2357 #[allow(deprecated)]
2358 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2359 where
2360 S: serde::Serializer,
2361 {
2362 let variant = match self {
2363 Self::Unspecified => "ENCODE_TYPE_UNSPECIFIED",
2364 Self::Native => "ENCODE_TYPE_NATIVE",
2365 Self::Avro => "ENCODE_TYPE_AVRO",
2366 Self::Csv => "ENCODE_TYPE_CSV",
2367 Self::Protobuf => "ENCODE_TYPE_PROTOBUF",
2368 Self::Json => "ENCODE_TYPE_JSON",
2369 Self::Bytes => "ENCODE_TYPE_BYTES",
2370 Self::Template => "ENCODE_TYPE_TEMPLATE",
2371 Self::None => "ENCODE_TYPE_NONE",
2372 Self::Text => "ENCODE_TYPE_TEXT",
2373 Self::Parquet => "ENCODE_TYPE_PARQUET",
2374 };
2375 serializer.serialize_str(variant)
2376 }
2377}
2378impl<'de> serde::Deserialize<'de> for EncodeType {
2379 #[allow(deprecated)]
2380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2381 where
2382 D: serde::Deserializer<'de>,
2383 {
2384 const FIELDS: &[&str] = &[
2385 "ENCODE_TYPE_UNSPECIFIED",
2386 "ENCODE_TYPE_NATIVE",
2387 "ENCODE_TYPE_AVRO",
2388 "ENCODE_TYPE_CSV",
2389 "ENCODE_TYPE_PROTOBUF",
2390 "ENCODE_TYPE_JSON",
2391 "ENCODE_TYPE_BYTES",
2392 "ENCODE_TYPE_TEMPLATE",
2393 "ENCODE_TYPE_NONE",
2394 "ENCODE_TYPE_TEXT",
2395 "ENCODE_TYPE_PARQUET",
2396 ];
2397
2398 struct GeneratedVisitor;
2399
2400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2401 type Value = EncodeType;
2402
2403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2404 write!(formatter, "expected one of: {:?}", &FIELDS)
2405 }
2406
2407 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2408 where
2409 E: serde::de::Error,
2410 {
2411 i32::try_from(v)
2412 .ok()
2413 .and_then(|x| x.try_into().ok())
2414 .ok_or_else(|| {
2415 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2416 })
2417 }
2418
2419 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2420 where
2421 E: serde::de::Error,
2422 {
2423 i32::try_from(v)
2424 .ok()
2425 .and_then(|x| x.try_into().ok())
2426 .ok_or_else(|| {
2427 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2428 })
2429 }
2430
2431 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2432 where
2433 E: serde::de::Error,
2434 {
2435 match value {
2436 "ENCODE_TYPE_UNSPECIFIED" => Ok(EncodeType::Unspecified),
2437 "ENCODE_TYPE_NATIVE" => Ok(EncodeType::Native),
2438 "ENCODE_TYPE_AVRO" => Ok(EncodeType::Avro),
2439 "ENCODE_TYPE_CSV" => Ok(EncodeType::Csv),
2440 "ENCODE_TYPE_PROTOBUF" => Ok(EncodeType::Protobuf),
2441 "ENCODE_TYPE_JSON" => Ok(EncodeType::Json),
2442 "ENCODE_TYPE_BYTES" => Ok(EncodeType::Bytes),
2443 "ENCODE_TYPE_TEMPLATE" => Ok(EncodeType::Template),
2444 "ENCODE_TYPE_NONE" => Ok(EncodeType::None),
2445 "ENCODE_TYPE_TEXT" => Ok(EncodeType::Text),
2446 "ENCODE_TYPE_PARQUET" => Ok(EncodeType::Parquet),
2447 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2448 }
2449 }
2450 }
2451 deserializer.deserialize_any(GeneratedVisitor)
2452 }
2453}
2454impl serde::Serialize for ExprContext {
2455 #[allow(deprecated)]
2456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2457 where
2458 S: serde::Serializer,
2459 {
2460 use serde::ser::SerializeStruct;
2461 let mut len = 0;
2462 if !self.time_zone.is_empty() {
2463 len += 1;
2464 }
2465 if self.strict_mode {
2466 len += 1;
2467 }
2468 let mut struct_ser = serializer.serialize_struct("plan_common.ExprContext", len)?;
2469 if !self.time_zone.is_empty() {
2470 struct_ser.serialize_field("timeZone", &self.time_zone)?;
2471 }
2472 if self.strict_mode {
2473 struct_ser.serialize_field("strictMode", &self.strict_mode)?;
2474 }
2475 struct_ser.end()
2476 }
2477}
2478impl<'de> serde::Deserialize<'de> for ExprContext {
2479 #[allow(deprecated)]
2480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2481 where
2482 D: serde::Deserializer<'de>,
2483 {
2484 const FIELDS: &[&str] = &[
2485 "time_zone",
2486 "timeZone",
2487 "strict_mode",
2488 "strictMode",
2489 ];
2490
2491 #[allow(clippy::enum_variant_names)]
2492 enum GeneratedField {
2493 TimeZone,
2494 StrictMode,
2495 }
2496 impl<'de> serde::Deserialize<'de> for GeneratedField {
2497 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2498 where
2499 D: serde::Deserializer<'de>,
2500 {
2501 struct GeneratedVisitor;
2502
2503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2504 type Value = GeneratedField;
2505
2506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2507 write!(formatter, "expected one of: {:?}", &FIELDS)
2508 }
2509
2510 #[allow(unused_variables)]
2511 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2512 where
2513 E: serde::de::Error,
2514 {
2515 match value {
2516 "timeZone" | "time_zone" => Ok(GeneratedField::TimeZone),
2517 "strictMode" | "strict_mode" => Ok(GeneratedField::StrictMode),
2518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2519 }
2520 }
2521 }
2522 deserializer.deserialize_identifier(GeneratedVisitor)
2523 }
2524 }
2525 struct GeneratedVisitor;
2526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2527 type Value = ExprContext;
2528
2529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2530 formatter.write_str("struct plan_common.ExprContext")
2531 }
2532
2533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExprContext, V::Error>
2534 where
2535 V: serde::de::MapAccess<'de>,
2536 {
2537 let mut time_zone__ = None;
2538 let mut strict_mode__ = None;
2539 while let Some(k) = map_.next_key()? {
2540 match k {
2541 GeneratedField::TimeZone => {
2542 if time_zone__.is_some() {
2543 return Err(serde::de::Error::duplicate_field("timeZone"));
2544 }
2545 time_zone__ = Some(map_.next_value()?);
2546 }
2547 GeneratedField::StrictMode => {
2548 if strict_mode__.is_some() {
2549 return Err(serde::de::Error::duplicate_field("strictMode"));
2550 }
2551 strict_mode__ = Some(map_.next_value()?);
2552 }
2553 }
2554 }
2555 Ok(ExprContext {
2556 time_zone: time_zone__.unwrap_or_default(),
2557 strict_mode: strict_mode__.unwrap_or_default(),
2558 })
2559 }
2560 }
2561 deserializer.deserialize_struct("plan_common.ExprContext", FIELDS, GeneratedVisitor)
2562 }
2563}
2564impl serde::Serialize for ExternalTableDesc {
2565 #[allow(deprecated)]
2566 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2567 where
2568 S: serde::Serializer,
2569 {
2570 use serde::ser::SerializeStruct;
2571 let mut len = 0;
2572 if self.table_id != 0 {
2573 len += 1;
2574 }
2575 if !self.columns.is_empty() {
2576 len += 1;
2577 }
2578 if !self.pk.is_empty() {
2579 len += 1;
2580 }
2581 if !self.table_name.is_empty() {
2582 len += 1;
2583 }
2584 if !self.stream_key.is_empty() {
2585 len += 1;
2586 }
2587 if !self.connect_properties.is_empty() {
2588 len += 1;
2589 }
2590 if self.source_id != 0 {
2591 len += 1;
2592 }
2593 if !self.secret_refs.is_empty() {
2594 len += 1;
2595 }
2596 let mut struct_ser = serializer.serialize_struct("plan_common.ExternalTableDesc", len)?;
2597 if self.table_id != 0 {
2598 struct_ser.serialize_field("tableId", &self.table_id)?;
2599 }
2600 if !self.columns.is_empty() {
2601 struct_ser.serialize_field("columns", &self.columns)?;
2602 }
2603 if !self.pk.is_empty() {
2604 struct_ser.serialize_field("pk", &self.pk)?;
2605 }
2606 if !self.table_name.is_empty() {
2607 struct_ser.serialize_field("tableName", &self.table_name)?;
2608 }
2609 if !self.stream_key.is_empty() {
2610 struct_ser.serialize_field("streamKey", &self.stream_key)?;
2611 }
2612 if !self.connect_properties.is_empty() {
2613 struct_ser.serialize_field("connectProperties", &self.connect_properties)?;
2614 }
2615 if self.source_id != 0 {
2616 struct_ser.serialize_field("sourceId", &self.source_id)?;
2617 }
2618 if !self.secret_refs.is_empty() {
2619 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
2620 }
2621 struct_ser.end()
2622 }
2623}
2624impl<'de> serde::Deserialize<'de> for ExternalTableDesc {
2625 #[allow(deprecated)]
2626 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2627 where
2628 D: serde::Deserializer<'de>,
2629 {
2630 const FIELDS: &[&str] = &[
2631 "table_id",
2632 "tableId",
2633 "columns",
2634 "pk",
2635 "table_name",
2636 "tableName",
2637 "stream_key",
2638 "streamKey",
2639 "connect_properties",
2640 "connectProperties",
2641 "source_id",
2642 "sourceId",
2643 "secret_refs",
2644 "secretRefs",
2645 ];
2646
2647 #[allow(clippy::enum_variant_names)]
2648 enum GeneratedField {
2649 TableId,
2650 Columns,
2651 Pk,
2652 TableName,
2653 StreamKey,
2654 ConnectProperties,
2655 SourceId,
2656 SecretRefs,
2657 }
2658 impl<'de> serde::Deserialize<'de> for GeneratedField {
2659 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2660 where
2661 D: serde::Deserializer<'de>,
2662 {
2663 struct GeneratedVisitor;
2664
2665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2666 type Value = GeneratedField;
2667
2668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2669 write!(formatter, "expected one of: {:?}", &FIELDS)
2670 }
2671
2672 #[allow(unused_variables)]
2673 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2674 where
2675 E: serde::de::Error,
2676 {
2677 match value {
2678 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2679 "columns" => Ok(GeneratedField::Columns),
2680 "pk" => Ok(GeneratedField::Pk),
2681 "tableName" | "table_name" => Ok(GeneratedField::TableName),
2682 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
2683 "connectProperties" | "connect_properties" => Ok(GeneratedField::ConnectProperties),
2684 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
2685 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
2686 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2687 }
2688 }
2689 }
2690 deserializer.deserialize_identifier(GeneratedVisitor)
2691 }
2692 }
2693 struct GeneratedVisitor;
2694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2695 type Value = ExternalTableDesc;
2696
2697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2698 formatter.write_str("struct plan_common.ExternalTableDesc")
2699 }
2700
2701 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExternalTableDesc, V::Error>
2702 where
2703 V: serde::de::MapAccess<'de>,
2704 {
2705 let mut table_id__ = None;
2706 let mut columns__ = None;
2707 let mut pk__ = None;
2708 let mut table_name__ = None;
2709 let mut stream_key__ = None;
2710 let mut connect_properties__ = None;
2711 let mut source_id__ = None;
2712 let mut secret_refs__ = None;
2713 while let Some(k) = map_.next_key()? {
2714 match k {
2715 GeneratedField::TableId => {
2716 if table_id__.is_some() {
2717 return Err(serde::de::Error::duplicate_field("tableId"));
2718 }
2719 table_id__ =
2720 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2721 ;
2722 }
2723 GeneratedField::Columns => {
2724 if columns__.is_some() {
2725 return Err(serde::de::Error::duplicate_field("columns"));
2726 }
2727 columns__ = Some(map_.next_value()?);
2728 }
2729 GeneratedField::Pk => {
2730 if pk__.is_some() {
2731 return Err(serde::de::Error::duplicate_field("pk"));
2732 }
2733 pk__ = Some(map_.next_value()?);
2734 }
2735 GeneratedField::TableName => {
2736 if table_name__.is_some() {
2737 return Err(serde::de::Error::duplicate_field("tableName"));
2738 }
2739 table_name__ = Some(map_.next_value()?);
2740 }
2741 GeneratedField::StreamKey => {
2742 if stream_key__.is_some() {
2743 return Err(serde::de::Error::duplicate_field("streamKey"));
2744 }
2745 stream_key__ =
2746 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2747 .into_iter().map(|x| x.0).collect())
2748 ;
2749 }
2750 GeneratedField::ConnectProperties => {
2751 if connect_properties__.is_some() {
2752 return Err(serde::de::Error::duplicate_field("connectProperties"));
2753 }
2754 connect_properties__ = Some(
2755 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2756 );
2757 }
2758 GeneratedField::SourceId => {
2759 if source_id__.is_some() {
2760 return Err(serde::de::Error::duplicate_field("sourceId"));
2761 }
2762 source_id__ =
2763 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2764 ;
2765 }
2766 GeneratedField::SecretRefs => {
2767 if secret_refs__.is_some() {
2768 return Err(serde::de::Error::duplicate_field("secretRefs"));
2769 }
2770 secret_refs__ = Some(
2771 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2772 );
2773 }
2774 }
2775 }
2776 Ok(ExternalTableDesc {
2777 table_id: table_id__.unwrap_or_default(),
2778 columns: columns__.unwrap_or_default(),
2779 pk: pk__.unwrap_or_default(),
2780 table_name: table_name__.unwrap_or_default(),
2781 stream_key: stream_key__.unwrap_or_default(),
2782 connect_properties: connect_properties__.unwrap_or_default(),
2783 source_id: source_id__.unwrap_or_default(),
2784 secret_refs: secret_refs__.unwrap_or_default(),
2785 })
2786 }
2787 }
2788 deserializer.deserialize_struct("plan_common.ExternalTableDesc", FIELDS, GeneratedVisitor)
2789 }
2790}
2791impl serde::Serialize for Field {
2792 #[allow(deprecated)]
2793 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2794 where
2795 S: serde::Serializer,
2796 {
2797 use serde::ser::SerializeStruct;
2798 let mut len = 0;
2799 if self.data_type.is_some() {
2800 len += 1;
2801 }
2802 if !self.name.is_empty() {
2803 len += 1;
2804 }
2805 let mut struct_ser = serializer.serialize_struct("plan_common.Field", len)?;
2806 if let Some(v) = self.data_type.as_ref() {
2807 struct_ser.serialize_field("dataType", v)?;
2808 }
2809 if !self.name.is_empty() {
2810 struct_ser.serialize_field("name", &self.name)?;
2811 }
2812 struct_ser.end()
2813 }
2814}
2815impl<'de> serde::Deserialize<'de> for Field {
2816 #[allow(deprecated)]
2817 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2818 where
2819 D: serde::Deserializer<'de>,
2820 {
2821 const FIELDS: &[&str] = &[
2822 "data_type",
2823 "dataType",
2824 "name",
2825 ];
2826
2827 #[allow(clippy::enum_variant_names)]
2828 enum GeneratedField {
2829 DataType,
2830 Name,
2831 }
2832 impl<'de> serde::Deserialize<'de> for GeneratedField {
2833 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2834 where
2835 D: serde::Deserializer<'de>,
2836 {
2837 struct GeneratedVisitor;
2838
2839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2840 type Value = GeneratedField;
2841
2842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2843 write!(formatter, "expected one of: {:?}", &FIELDS)
2844 }
2845
2846 #[allow(unused_variables)]
2847 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2848 where
2849 E: serde::de::Error,
2850 {
2851 match value {
2852 "dataType" | "data_type" => Ok(GeneratedField::DataType),
2853 "name" => Ok(GeneratedField::Name),
2854 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2855 }
2856 }
2857 }
2858 deserializer.deserialize_identifier(GeneratedVisitor)
2859 }
2860 }
2861 struct GeneratedVisitor;
2862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2863 type Value = Field;
2864
2865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2866 formatter.write_str("struct plan_common.Field")
2867 }
2868
2869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Field, V::Error>
2870 where
2871 V: serde::de::MapAccess<'de>,
2872 {
2873 let mut data_type__ = None;
2874 let mut name__ = None;
2875 while let Some(k) = map_.next_key()? {
2876 match k {
2877 GeneratedField::DataType => {
2878 if data_type__.is_some() {
2879 return Err(serde::de::Error::duplicate_field("dataType"));
2880 }
2881 data_type__ = map_.next_value()?;
2882 }
2883 GeneratedField::Name => {
2884 if name__.is_some() {
2885 return Err(serde::de::Error::duplicate_field("name"));
2886 }
2887 name__ = Some(map_.next_value()?);
2888 }
2889 }
2890 }
2891 Ok(Field {
2892 data_type: data_type__,
2893 name: name__.unwrap_or_default(),
2894 })
2895 }
2896 }
2897 deserializer.deserialize_struct("plan_common.Field", FIELDS, GeneratedVisitor)
2898 }
2899}
2900impl serde::Serialize for FormatType {
2901 #[allow(deprecated)]
2902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2903 where
2904 S: serde::Serializer,
2905 {
2906 let variant = match self {
2907 Self::Unspecified => "FORMAT_TYPE_UNSPECIFIED",
2908 Self::Native => "FORMAT_TYPE_NATIVE",
2909 Self::Debezium => "FORMAT_TYPE_DEBEZIUM",
2910 Self::DebeziumMongo => "FORMAT_TYPE_DEBEZIUM_MONGO",
2911 Self::Maxwell => "FORMAT_TYPE_MAXWELL",
2912 Self::Canal => "FORMAT_TYPE_CANAL",
2913 Self::Upsert => "FORMAT_TYPE_UPSERT",
2914 Self::Plain => "FORMAT_TYPE_PLAIN",
2915 Self::None => "FORMAT_TYPE_NONE",
2916 };
2917 serializer.serialize_str(variant)
2918 }
2919}
2920impl<'de> serde::Deserialize<'de> for FormatType {
2921 #[allow(deprecated)]
2922 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2923 where
2924 D: serde::Deserializer<'de>,
2925 {
2926 const FIELDS: &[&str] = &[
2927 "FORMAT_TYPE_UNSPECIFIED",
2928 "FORMAT_TYPE_NATIVE",
2929 "FORMAT_TYPE_DEBEZIUM",
2930 "FORMAT_TYPE_DEBEZIUM_MONGO",
2931 "FORMAT_TYPE_MAXWELL",
2932 "FORMAT_TYPE_CANAL",
2933 "FORMAT_TYPE_UPSERT",
2934 "FORMAT_TYPE_PLAIN",
2935 "FORMAT_TYPE_NONE",
2936 ];
2937
2938 struct GeneratedVisitor;
2939
2940 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2941 type Value = FormatType;
2942
2943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2944 write!(formatter, "expected one of: {:?}", &FIELDS)
2945 }
2946
2947 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2948 where
2949 E: serde::de::Error,
2950 {
2951 i32::try_from(v)
2952 .ok()
2953 .and_then(|x| x.try_into().ok())
2954 .ok_or_else(|| {
2955 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2956 })
2957 }
2958
2959 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2960 where
2961 E: serde::de::Error,
2962 {
2963 i32::try_from(v)
2964 .ok()
2965 .and_then(|x| x.try_into().ok())
2966 .ok_or_else(|| {
2967 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2968 })
2969 }
2970
2971 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2972 where
2973 E: serde::de::Error,
2974 {
2975 match value {
2976 "FORMAT_TYPE_UNSPECIFIED" => Ok(FormatType::Unspecified),
2977 "FORMAT_TYPE_NATIVE" => Ok(FormatType::Native),
2978 "FORMAT_TYPE_DEBEZIUM" => Ok(FormatType::Debezium),
2979 "FORMAT_TYPE_DEBEZIUM_MONGO" => Ok(FormatType::DebeziumMongo),
2980 "FORMAT_TYPE_MAXWELL" => Ok(FormatType::Maxwell),
2981 "FORMAT_TYPE_CANAL" => Ok(FormatType::Canal),
2982 "FORMAT_TYPE_UPSERT" => Ok(FormatType::Upsert),
2983 "FORMAT_TYPE_PLAIN" => Ok(FormatType::Plain),
2984 "FORMAT_TYPE_NONE" => Ok(FormatType::None),
2985 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2986 }
2987 }
2988 }
2989 deserializer.deserialize_any(GeneratedVisitor)
2990 }
2991}
2992impl serde::Serialize for GeneratedColumnDesc {
2993 #[allow(deprecated)]
2994 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2995 where
2996 S: serde::Serializer,
2997 {
2998 use serde::ser::SerializeStruct;
2999 let mut len = 0;
3000 if self.expr.is_some() {
3001 len += 1;
3002 }
3003 let mut struct_ser = serializer.serialize_struct("plan_common.GeneratedColumnDesc", len)?;
3004 if let Some(v) = self.expr.as_ref() {
3005 struct_ser.serialize_field("expr", v)?;
3006 }
3007 struct_ser.end()
3008 }
3009}
3010impl<'de> serde::Deserialize<'de> for GeneratedColumnDesc {
3011 #[allow(deprecated)]
3012 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3013 where
3014 D: serde::Deserializer<'de>,
3015 {
3016 const FIELDS: &[&str] = &[
3017 "expr",
3018 ];
3019
3020 #[allow(clippy::enum_variant_names)]
3021 enum GeneratedField {
3022 Expr,
3023 }
3024 impl<'de> serde::Deserialize<'de> for GeneratedField {
3025 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3026 where
3027 D: serde::Deserializer<'de>,
3028 {
3029 struct GeneratedVisitor;
3030
3031 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3032 type Value = GeneratedField;
3033
3034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3035 write!(formatter, "expected one of: {:?}", &FIELDS)
3036 }
3037
3038 #[allow(unused_variables)]
3039 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3040 where
3041 E: serde::de::Error,
3042 {
3043 match value {
3044 "expr" => Ok(GeneratedField::Expr),
3045 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3046 }
3047 }
3048 }
3049 deserializer.deserialize_identifier(GeneratedVisitor)
3050 }
3051 }
3052 struct GeneratedVisitor;
3053 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3054 type Value = GeneratedColumnDesc;
3055
3056 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3057 formatter.write_str("struct plan_common.GeneratedColumnDesc")
3058 }
3059
3060 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GeneratedColumnDesc, V::Error>
3061 where
3062 V: serde::de::MapAccess<'de>,
3063 {
3064 let mut expr__ = None;
3065 while let Some(k) = map_.next_key()? {
3066 match k {
3067 GeneratedField::Expr => {
3068 if expr__.is_some() {
3069 return Err(serde::de::Error::duplicate_field("expr"));
3070 }
3071 expr__ = map_.next_value()?;
3072 }
3073 }
3074 }
3075 Ok(GeneratedColumnDesc {
3076 expr: expr__,
3077 })
3078 }
3079 }
3080 deserializer.deserialize_struct("plan_common.GeneratedColumnDesc", FIELDS, GeneratedVisitor)
3081 }
3082}
3083impl serde::Serialize for IndexAndExpr {
3084 #[allow(deprecated)]
3085 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3086 where
3087 S: serde::Serializer,
3088 {
3089 use serde::ser::SerializeStruct;
3090 let mut len = 0;
3091 if self.index != 0 {
3092 len += 1;
3093 }
3094 if self.expr.is_some() {
3095 len += 1;
3096 }
3097 let mut struct_ser = serializer.serialize_struct("plan_common.IndexAndExpr", len)?;
3098 if self.index != 0 {
3099 struct_ser.serialize_field("index", &self.index)?;
3100 }
3101 if let Some(v) = self.expr.as_ref() {
3102 struct_ser.serialize_field("expr", v)?;
3103 }
3104 struct_ser.end()
3105 }
3106}
3107impl<'de> serde::Deserialize<'de> for IndexAndExpr {
3108 #[allow(deprecated)]
3109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3110 where
3111 D: serde::Deserializer<'de>,
3112 {
3113 const FIELDS: &[&str] = &[
3114 "index",
3115 "expr",
3116 ];
3117
3118 #[allow(clippy::enum_variant_names)]
3119 enum GeneratedField {
3120 Index,
3121 Expr,
3122 }
3123 impl<'de> serde::Deserialize<'de> for GeneratedField {
3124 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3125 where
3126 D: serde::Deserializer<'de>,
3127 {
3128 struct GeneratedVisitor;
3129
3130 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3131 type Value = GeneratedField;
3132
3133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3134 write!(formatter, "expected one of: {:?}", &FIELDS)
3135 }
3136
3137 #[allow(unused_variables)]
3138 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3139 where
3140 E: serde::de::Error,
3141 {
3142 match value {
3143 "index" => Ok(GeneratedField::Index),
3144 "expr" => Ok(GeneratedField::Expr),
3145 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3146 }
3147 }
3148 }
3149 deserializer.deserialize_identifier(GeneratedVisitor)
3150 }
3151 }
3152 struct GeneratedVisitor;
3153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3154 type Value = IndexAndExpr;
3155
3156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3157 formatter.write_str("struct plan_common.IndexAndExpr")
3158 }
3159
3160 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IndexAndExpr, V::Error>
3161 where
3162 V: serde::de::MapAccess<'de>,
3163 {
3164 let mut index__ = None;
3165 let mut expr__ = None;
3166 while let Some(k) = map_.next_key()? {
3167 match k {
3168 GeneratedField::Index => {
3169 if index__.is_some() {
3170 return Err(serde::de::Error::duplicate_field("index"));
3171 }
3172 index__ =
3173 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3174 ;
3175 }
3176 GeneratedField::Expr => {
3177 if expr__.is_some() {
3178 return Err(serde::de::Error::duplicate_field("expr"));
3179 }
3180 expr__ = map_.next_value()?;
3181 }
3182 }
3183 }
3184 Ok(IndexAndExpr {
3185 index: index__.unwrap_or_default(),
3186 expr: expr__,
3187 })
3188 }
3189 }
3190 deserializer.deserialize_struct("plan_common.IndexAndExpr", FIELDS, GeneratedVisitor)
3191 }
3192}
3193impl serde::Serialize for JoinType {
3194 #[allow(deprecated)]
3195 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3196 where
3197 S: serde::Serializer,
3198 {
3199 let variant = match self {
3200 Self::Unspecified => "JOIN_TYPE_UNSPECIFIED",
3201 Self::Inner => "JOIN_TYPE_INNER",
3202 Self::LeftOuter => "JOIN_TYPE_LEFT_OUTER",
3203 Self::RightOuter => "JOIN_TYPE_RIGHT_OUTER",
3204 Self::FullOuter => "JOIN_TYPE_FULL_OUTER",
3205 Self::LeftSemi => "JOIN_TYPE_LEFT_SEMI",
3206 Self::LeftAnti => "JOIN_TYPE_LEFT_ANTI",
3207 Self::RightSemi => "JOIN_TYPE_RIGHT_SEMI",
3208 Self::RightAnti => "JOIN_TYPE_RIGHT_ANTI",
3209 Self::AsofInner => "JOIN_TYPE_ASOF_INNER",
3210 Self::AsofLeftOuter => "JOIN_TYPE_ASOF_LEFT_OUTER",
3211 };
3212 serializer.serialize_str(variant)
3213 }
3214}
3215impl<'de> serde::Deserialize<'de> for JoinType {
3216 #[allow(deprecated)]
3217 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3218 where
3219 D: serde::Deserializer<'de>,
3220 {
3221 const FIELDS: &[&str] = &[
3222 "JOIN_TYPE_UNSPECIFIED",
3223 "JOIN_TYPE_INNER",
3224 "JOIN_TYPE_LEFT_OUTER",
3225 "JOIN_TYPE_RIGHT_OUTER",
3226 "JOIN_TYPE_FULL_OUTER",
3227 "JOIN_TYPE_LEFT_SEMI",
3228 "JOIN_TYPE_LEFT_ANTI",
3229 "JOIN_TYPE_RIGHT_SEMI",
3230 "JOIN_TYPE_RIGHT_ANTI",
3231 "JOIN_TYPE_ASOF_INNER",
3232 "JOIN_TYPE_ASOF_LEFT_OUTER",
3233 ];
3234
3235 struct GeneratedVisitor;
3236
3237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3238 type Value = JoinType;
3239
3240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3241 write!(formatter, "expected one of: {:?}", &FIELDS)
3242 }
3243
3244 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3245 where
3246 E: serde::de::Error,
3247 {
3248 i32::try_from(v)
3249 .ok()
3250 .and_then(|x| x.try_into().ok())
3251 .ok_or_else(|| {
3252 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3253 })
3254 }
3255
3256 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3257 where
3258 E: serde::de::Error,
3259 {
3260 i32::try_from(v)
3261 .ok()
3262 .and_then(|x| x.try_into().ok())
3263 .ok_or_else(|| {
3264 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3265 })
3266 }
3267
3268 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3269 where
3270 E: serde::de::Error,
3271 {
3272 match value {
3273 "JOIN_TYPE_UNSPECIFIED" => Ok(JoinType::Unspecified),
3274 "JOIN_TYPE_INNER" => Ok(JoinType::Inner),
3275 "JOIN_TYPE_LEFT_OUTER" => Ok(JoinType::LeftOuter),
3276 "JOIN_TYPE_RIGHT_OUTER" => Ok(JoinType::RightOuter),
3277 "JOIN_TYPE_FULL_OUTER" => Ok(JoinType::FullOuter),
3278 "JOIN_TYPE_LEFT_SEMI" => Ok(JoinType::LeftSemi),
3279 "JOIN_TYPE_LEFT_ANTI" => Ok(JoinType::LeftAnti),
3280 "JOIN_TYPE_RIGHT_SEMI" => Ok(JoinType::RightSemi),
3281 "JOIN_TYPE_RIGHT_ANTI" => Ok(JoinType::RightAnti),
3282 "JOIN_TYPE_ASOF_INNER" => Ok(JoinType::AsofInner),
3283 "JOIN_TYPE_ASOF_LEFT_OUTER" => Ok(JoinType::AsofLeftOuter),
3284 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3285 }
3286 }
3287 }
3288 deserializer.deserialize_any(GeneratedVisitor)
3289 }
3290}
3291impl serde::Serialize for RowFormatType {
3292 #[allow(deprecated)]
3293 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3294 where
3295 S: serde::Serializer,
3296 {
3297 let variant = match self {
3298 Self::RowUnspecified => "ROW_UNSPECIFIED",
3299 Self::Json => "JSON",
3300 Self::Protobuf => "PROTOBUF",
3301 Self::DebeziumJson => "DEBEZIUM_JSON",
3302 Self::Avro => "AVRO",
3303 Self::Maxwell => "MAXWELL",
3304 Self::CanalJson => "CANAL_JSON",
3305 Self::Csv => "CSV",
3306 Self::Native => "NATIVE",
3307 Self::DebeziumAvro => "DEBEZIUM_AVRO",
3308 Self::UpsertJson => "UPSERT_JSON",
3309 Self::UpsertAvro => "UPSERT_AVRO",
3310 Self::DebeziumMongoJson => "DEBEZIUM_MONGO_JSON",
3311 Self::Bytes => "BYTES",
3312 };
3313 serializer.serialize_str(variant)
3314 }
3315}
3316impl<'de> serde::Deserialize<'de> for RowFormatType {
3317 #[allow(deprecated)]
3318 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3319 where
3320 D: serde::Deserializer<'de>,
3321 {
3322 const FIELDS: &[&str] = &[
3323 "ROW_UNSPECIFIED",
3324 "JSON",
3325 "PROTOBUF",
3326 "DEBEZIUM_JSON",
3327 "AVRO",
3328 "MAXWELL",
3329 "CANAL_JSON",
3330 "CSV",
3331 "NATIVE",
3332 "DEBEZIUM_AVRO",
3333 "UPSERT_JSON",
3334 "UPSERT_AVRO",
3335 "DEBEZIUM_MONGO_JSON",
3336 "BYTES",
3337 ];
3338
3339 struct GeneratedVisitor;
3340
3341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3342 type Value = RowFormatType;
3343
3344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3345 write!(formatter, "expected one of: {:?}", &FIELDS)
3346 }
3347
3348 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3349 where
3350 E: serde::de::Error,
3351 {
3352 i32::try_from(v)
3353 .ok()
3354 .and_then(|x| x.try_into().ok())
3355 .ok_or_else(|| {
3356 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3357 })
3358 }
3359
3360 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3361 where
3362 E: serde::de::Error,
3363 {
3364 i32::try_from(v)
3365 .ok()
3366 .and_then(|x| x.try_into().ok())
3367 .ok_or_else(|| {
3368 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3369 })
3370 }
3371
3372 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3373 where
3374 E: serde::de::Error,
3375 {
3376 match value {
3377 "ROW_UNSPECIFIED" => Ok(RowFormatType::RowUnspecified),
3378 "JSON" => Ok(RowFormatType::Json),
3379 "PROTOBUF" => Ok(RowFormatType::Protobuf),
3380 "DEBEZIUM_JSON" => Ok(RowFormatType::DebeziumJson),
3381 "AVRO" => Ok(RowFormatType::Avro),
3382 "MAXWELL" => Ok(RowFormatType::Maxwell),
3383 "CANAL_JSON" => Ok(RowFormatType::CanalJson),
3384 "CSV" => Ok(RowFormatType::Csv),
3385 "NATIVE" => Ok(RowFormatType::Native),
3386 "DEBEZIUM_AVRO" => Ok(RowFormatType::DebeziumAvro),
3387 "UPSERT_JSON" => Ok(RowFormatType::UpsertJson),
3388 "UPSERT_AVRO" => Ok(RowFormatType::UpsertAvro),
3389 "DEBEZIUM_MONGO_JSON" => Ok(RowFormatType::DebeziumMongoJson),
3390 "BYTES" => Ok(RowFormatType::Bytes),
3391 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3392 }
3393 }
3394 }
3395 deserializer.deserialize_any(GeneratedVisitor)
3396 }
3397}
3398impl serde::Serialize for StorageTableDesc {
3399 #[allow(deprecated)]
3400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3401 where
3402 S: serde::Serializer,
3403 {
3404 use serde::ser::SerializeStruct;
3405 let mut len = 0;
3406 if self.table_id != 0 {
3407 len += 1;
3408 }
3409 if !self.columns.is_empty() {
3410 len += 1;
3411 }
3412 if !self.pk.is_empty() {
3413 len += 1;
3414 }
3415 if !self.dist_key_in_pk_indices.is_empty() {
3416 len += 1;
3417 }
3418 if !self.value_indices.is_empty() {
3419 len += 1;
3420 }
3421 if self.read_prefix_len_hint != 0 {
3422 len += 1;
3423 }
3424 if self.versioned {
3425 len += 1;
3426 }
3427 if !self.stream_key.is_empty() {
3428 len += 1;
3429 }
3430 if self.vnode_col_idx_in_pk.is_some() {
3431 len += 1;
3432 }
3433 if self.retention_seconds.is_some() {
3434 len += 1;
3435 }
3436 if self.maybe_vnode_count.is_some() {
3437 len += 1;
3438 }
3439 let mut struct_ser = serializer.serialize_struct("plan_common.StorageTableDesc", len)?;
3440 if self.table_id != 0 {
3441 struct_ser.serialize_field("tableId", &self.table_id)?;
3442 }
3443 if !self.columns.is_empty() {
3444 struct_ser.serialize_field("columns", &self.columns)?;
3445 }
3446 if !self.pk.is_empty() {
3447 struct_ser.serialize_field("pk", &self.pk)?;
3448 }
3449 if !self.dist_key_in_pk_indices.is_empty() {
3450 struct_ser.serialize_field("distKeyInPkIndices", &self.dist_key_in_pk_indices)?;
3451 }
3452 if !self.value_indices.is_empty() {
3453 struct_ser.serialize_field("valueIndices", &self.value_indices)?;
3454 }
3455 if self.read_prefix_len_hint != 0 {
3456 struct_ser.serialize_field("readPrefixLenHint", &self.read_prefix_len_hint)?;
3457 }
3458 if self.versioned {
3459 struct_ser.serialize_field("versioned", &self.versioned)?;
3460 }
3461 if !self.stream_key.is_empty() {
3462 struct_ser.serialize_field("streamKey", &self.stream_key)?;
3463 }
3464 if let Some(v) = self.vnode_col_idx_in_pk.as_ref() {
3465 struct_ser.serialize_field("vnodeColIdxInPk", v)?;
3466 }
3467 if let Some(v) = self.retention_seconds.as_ref() {
3468 struct_ser.serialize_field("retentionSeconds", v)?;
3469 }
3470 if let Some(v) = self.maybe_vnode_count.as_ref() {
3471 struct_ser.serialize_field("maybeVnodeCount", v)?;
3472 }
3473 struct_ser.end()
3474 }
3475}
3476impl<'de> serde::Deserialize<'de> for StorageTableDesc {
3477 #[allow(deprecated)]
3478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3479 where
3480 D: serde::Deserializer<'de>,
3481 {
3482 const FIELDS: &[&str] = &[
3483 "table_id",
3484 "tableId",
3485 "columns",
3486 "pk",
3487 "dist_key_in_pk_indices",
3488 "distKeyInPkIndices",
3489 "value_indices",
3490 "valueIndices",
3491 "read_prefix_len_hint",
3492 "readPrefixLenHint",
3493 "versioned",
3494 "stream_key",
3495 "streamKey",
3496 "vnode_col_idx_in_pk",
3497 "vnodeColIdxInPk",
3498 "retention_seconds",
3499 "retentionSeconds",
3500 "maybe_vnode_count",
3501 "maybeVnodeCount",
3502 ];
3503
3504 #[allow(clippy::enum_variant_names)]
3505 enum GeneratedField {
3506 TableId,
3507 Columns,
3508 Pk,
3509 DistKeyInPkIndices,
3510 ValueIndices,
3511 ReadPrefixLenHint,
3512 Versioned,
3513 StreamKey,
3514 VnodeColIdxInPk,
3515 RetentionSeconds,
3516 MaybeVnodeCount,
3517 }
3518 impl<'de> serde::Deserialize<'de> for GeneratedField {
3519 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3520 where
3521 D: serde::Deserializer<'de>,
3522 {
3523 struct GeneratedVisitor;
3524
3525 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3526 type Value = GeneratedField;
3527
3528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3529 write!(formatter, "expected one of: {:?}", &FIELDS)
3530 }
3531
3532 #[allow(unused_variables)]
3533 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3534 where
3535 E: serde::de::Error,
3536 {
3537 match value {
3538 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3539 "columns" => Ok(GeneratedField::Columns),
3540 "pk" => Ok(GeneratedField::Pk),
3541 "distKeyInPkIndices" | "dist_key_in_pk_indices" => Ok(GeneratedField::DistKeyInPkIndices),
3542 "valueIndices" | "value_indices" => Ok(GeneratedField::ValueIndices),
3543 "readPrefixLenHint" | "read_prefix_len_hint" => Ok(GeneratedField::ReadPrefixLenHint),
3544 "versioned" => Ok(GeneratedField::Versioned),
3545 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
3546 "vnodeColIdxInPk" | "vnode_col_idx_in_pk" => Ok(GeneratedField::VnodeColIdxInPk),
3547 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
3548 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
3549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3550 }
3551 }
3552 }
3553 deserializer.deserialize_identifier(GeneratedVisitor)
3554 }
3555 }
3556 struct GeneratedVisitor;
3557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3558 type Value = StorageTableDesc;
3559
3560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3561 formatter.write_str("struct plan_common.StorageTableDesc")
3562 }
3563
3564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StorageTableDesc, V::Error>
3565 where
3566 V: serde::de::MapAccess<'de>,
3567 {
3568 let mut table_id__ = None;
3569 let mut columns__ = None;
3570 let mut pk__ = None;
3571 let mut dist_key_in_pk_indices__ = None;
3572 let mut value_indices__ = None;
3573 let mut read_prefix_len_hint__ = None;
3574 let mut versioned__ = None;
3575 let mut stream_key__ = None;
3576 let mut vnode_col_idx_in_pk__ = None;
3577 let mut retention_seconds__ = None;
3578 let mut maybe_vnode_count__ = None;
3579 while let Some(k) = map_.next_key()? {
3580 match k {
3581 GeneratedField::TableId => {
3582 if table_id__.is_some() {
3583 return Err(serde::de::Error::duplicate_field("tableId"));
3584 }
3585 table_id__ =
3586 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3587 ;
3588 }
3589 GeneratedField::Columns => {
3590 if columns__.is_some() {
3591 return Err(serde::de::Error::duplicate_field("columns"));
3592 }
3593 columns__ = Some(map_.next_value()?);
3594 }
3595 GeneratedField::Pk => {
3596 if pk__.is_some() {
3597 return Err(serde::de::Error::duplicate_field("pk"));
3598 }
3599 pk__ = Some(map_.next_value()?);
3600 }
3601 GeneratedField::DistKeyInPkIndices => {
3602 if dist_key_in_pk_indices__.is_some() {
3603 return Err(serde::de::Error::duplicate_field("distKeyInPkIndices"));
3604 }
3605 dist_key_in_pk_indices__ =
3606 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3607 .into_iter().map(|x| x.0).collect())
3608 ;
3609 }
3610 GeneratedField::ValueIndices => {
3611 if value_indices__.is_some() {
3612 return Err(serde::de::Error::duplicate_field("valueIndices"));
3613 }
3614 value_indices__ =
3615 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3616 .into_iter().map(|x| x.0).collect())
3617 ;
3618 }
3619 GeneratedField::ReadPrefixLenHint => {
3620 if read_prefix_len_hint__.is_some() {
3621 return Err(serde::de::Error::duplicate_field("readPrefixLenHint"));
3622 }
3623 read_prefix_len_hint__ =
3624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3625 ;
3626 }
3627 GeneratedField::Versioned => {
3628 if versioned__.is_some() {
3629 return Err(serde::de::Error::duplicate_field("versioned"));
3630 }
3631 versioned__ = Some(map_.next_value()?);
3632 }
3633 GeneratedField::StreamKey => {
3634 if stream_key__.is_some() {
3635 return Err(serde::de::Error::duplicate_field("streamKey"));
3636 }
3637 stream_key__ =
3638 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3639 .into_iter().map(|x| x.0).collect())
3640 ;
3641 }
3642 GeneratedField::VnodeColIdxInPk => {
3643 if vnode_col_idx_in_pk__.is_some() {
3644 return Err(serde::de::Error::duplicate_field("vnodeColIdxInPk"));
3645 }
3646 vnode_col_idx_in_pk__ =
3647 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3648 ;
3649 }
3650 GeneratedField::RetentionSeconds => {
3651 if retention_seconds__.is_some() {
3652 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
3653 }
3654 retention_seconds__ =
3655 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3656 ;
3657 }
3658 GeneratedField::MaybeVnodeCount => {
3659 if maybe_vnode_count__.is_some() {
3660 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
3661 }
3662 maybe_vnode_count__ =
3663 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3664 ;
3665 }
3666 }
3667 }
3668 Ok(StorageTableDesc {
3669 table_id: table_id__.unwrap_or_default(),
3670 columns: columns__.unwrap_or_default(),
3671 pk: pk__.unwrap_or_default(),
3672 dist_key_in_pk_indices: dist_key_in_pk_indices__.unwrap_or_default(),
3673 value_indices: value_indices__.unwrap_or_default(),
3674 read_prefix_len_hint: read_prefix_len_hint__.unwrap_or_default(),
3675 versioned: versioned__.unwrap_or_default(),
3676 stream_key: stream_key__.unwrap_or_default(),
3677 vnode_col_idx_in_pk: vnode_col_idx_in_pk__,
3678 retention_seconds: retention_seconds__,
3679 maybe_vnode_count: maybe_vnode_count__,
3680 })
3681 }
3682 }
3683 deserializer.deserialize_struct("plan_common.StorageTableDesc", FIELDS, GeneratedVisitor)
3684 }
3685}
3686impl serde::Serialize for VectorIndexReaderDesc {
3687 #[allow(deprecated)]
3688 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3689 where
3690 S: serde::Serializer,
3691 {
3692 use serde::ser::SerializeStruct;
3693 let mut len = 0;
3694 if self.table_id != 0 {
3695 len += 1;
3696 }
3697 if !self.info_column_desc.is_empty() {
3698 len += 1;
3699 }
3700 if !self.info_output_indices.is_empty() {
3701 len += 1;
3702 }
3703 if self.include_distance {
3704 len += 1;
3705 }
3706 if self.top_n != 0 {
3707 len += 1;
3708 }
3709 if self.distance_type != 0 {
3710 len += 1;
3711 }
3712 if self.hnsw_ef_search != 0 {
3713 len += 1;
3714 }
3715 let mut struct_ser = serializer.serialize_struct("plan_common.VectorIndexReaderDesc", len)?;
3716 if self.table_id != 0 {
3717 struct_ser.serialize_field("tableId", &self.table_id)?;
3718 }
3719 if !self.info_column_desc.is_empty() {
3720 struct_ser.serialize_field("infoColumnDesc", &self.info_column_desc)?;
3721 }
3722 if !self.info_output_indices.is_empty() {
3723 struct_ser.serialize_field("infoOutputIndices", &self.info_output_indices)?;
3724 }
3725 if self.include_distance {
3726 struct_ser.serialize_field("includeDistance", &self.include_distance)?;
3727 }
3728 if self.top_n != 0 {
3729 struct_ser.serialize_field("topN", &self.top_n)?;
3730 }
3731 if self.distance_type != 0 {
3732 let v = super::common::DistanceType::try_from(self.distance_type)
3733 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
3734 struct_ser.serialize_field("distanceType", &v)?;
3735 }
3736 if self.hnsw_ef_search != 0 {
3737 struct_ser.serialize_field("hnswEfSearch", &self.hnsw_ef_search)?;
3738 }
3739 struct_ser.end()
3740 }
3741}
3742impl<'de> serde::Deserialize<'de> for VectorIndexReaderDesc {
3743 #[allow(deprecated)]
3744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3745 where
3746 D: serde::Deserializer<'de>,
3747 {
3748 const FIELDS: &[&str] = &[
3749 "table_id",
3750 "tableId",
3751 "info_column_desc",
3752 "infoColumnDesc",
3753 "info_output_indices",
3754 "infoOutputIndices",
3755 "include_distance",
3756 "includeDistance",
3757 "top_n",
3758 "topN",
3759 "distance_type",
3760 "distanceType",
3761 "hnsw_ef_search",
3762 "hnswEfSearch",
3763 ];
3764
3765 #[allow(clippy::enum_variant_names)]
3766 enum GeneratedField {
3767 TableId,
3768 InfoColumnDesc,
3769 InfoOutputIndices,
3770 IncludeDistance,
3771 TopN,
3772 DistanceType,
3773 HnswEfSearch,
3774 }
3775 impl<'de> serde::Deserialize<'de> for GeneratedField {
3776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3777 where
3778 D: serde::Deserializer<'de>,
3779 {
3780 struct GeneratedVisitor;
3781
3782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3783 type Value = GeneratedField;
3784
3785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3786 write!(formatter, "expected one of: {:?}", &FIELDS)
3787 }
3788
3789 #[allow(unused_variables)]
3790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3791 where
3792 E: serde::de::Error,
3793 {
3794 match value {
3795 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3796 "infoColumnDesc" | "info_column_desc" => Ok(GeneratedField::InfoColumnDesc),
3797 "infoOutputIndices" | "info_output_indices" => Ok(GeneratedField::InfoOutputIndices),
3798 "includeDistance" | "include_distance" => Ok(GeneratedField::IncludeDistance),
3799 "topN" | "top_n" => Ok(GeneratedField::TopN),
3800 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
3801 "hnswEfSearch" | "hnsw_ef_search" => Ok(GeneratedField::HnswEfSearch),
3802 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3803 }
3804 }
3805 }
3806 deserializer.deserialize_identifier(GeneratedVisitor)
3807 }
3808 }
3809 struct GeneratedVisitor;
3810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3811 type Value = VectorIndexReaderDesc;
3812
3813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3814 formatter.write_str("struct plan_common.VectorIndexReaderDesc")
3815 }
3816
3817 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexReaderDesc, V::Error>
3818 where
3819 V: serde::de::MapAccess<'de>,
3820 {
3821 let mut table_id__ = None;
3822 let mut info_column_desc__ = None;
3823 let mut info_output_indices__ = None;
3824 let mut include_distance__ = None;
3825 let mut top_n__ = None;
3826 let mut distance_type__ = None;
3827 let mut hnsw_ef_search__ = None;
3828 while let Some(k) = map_.next_key()? {
3829 match k {
3830 GeneratedField::TableId => {
3831 if table_id__.is_some() {
3832 return Err(serde::de::Error::duplicate_field("tableId"));
3833 }
3834 table_id__ =
3835 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3836 ;
3837 }
3838 GeneratedField::InfoColumnDesc => {
3839 if info_column_desc__.is_some() {
3840 return Err(serde::de::Error::duplicate_field("infoColumnDesc"));
3841 }
3842 info_column_desc__ = Some(map_.next_value()?);
3843 }
3844 GeneratedField::InfoOutputIndices => {
3845 if info_output_indices__.is_some() {
3846 return Err(serde::de::Error::duplicate_field("infoOutputIndices"));
3847 }
3848 info_output_indices__ =
3849 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3850 .into_iter().map(|x| x.0).collect())
3851 ;
3852 }
3853 GeneratedField::IncludeDistance => {
3854 if include_distance__.is_some() {
3855 return Err(serde::de::Error::duplicate_field("includeDistance"));
3856 }
3857 include_distance__ = Some(map_.next_value()?);
3858 }
3859 GeneratedField::TopN => {
3860 if top_n__.is_some() {
3861 return Err(serde::de::Error::duplicate_field("topN"));
3862 }
3863 top_n__ =
3864 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3865 ;
3866 }
3867 GeneratedField::DistanceType => {
3868 if distance_type__.is_some() {
3869 return Err(serde::de::Error::duplicate_field("distanceType"));
3870 }
3871 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
3872 }
3873 GeneratedField::HnswEfSearch => {
3874 if hnsw_ef_search__.is_some() {
3875 return Err(serde::de::Error::duplicate_field("hnswEfSearch"));
3876 }
3877 hnsw_ef_search__ =
3878 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3879 ;
3880 }
3881 }
3882 }
3883 Ok(VectorIndexReaderDesc {
3884 table_id: table_id__.unwrap_or_default(),
3885 info_column_desc: info_column_desc__.unwrap_or_default(),
3886 info_output_indices: info_output_indices__.unwrap_or_default(),
3887 include_distance: include_distance__.unwrap_or_default(),
3888 top_n: top_n__.unwrap_or_default(),
3889 distance_type: distance_type__.unwrap_or_default(),
3890 hnsw_ef_search: hnsw_ef_search__.unwrap_or_default(),
3891 })
3892 }
3893 }
3894 deserializer.deserialize_struct("plan_common.VectorIndexReaderDesc", FIELDS, GeneratedVisitor)
3895 }
3896}