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