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