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