risingwave_pb/
data.serde.rs

1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::data::*;
4impl serde::Serialize for Array {
5    #[allow(deprecated)]
6    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7    where
8        S: serde::Serializer,
9    {
10        use serde::ser::SerializeStruct;
11        let mut len = 0;
12        if self.array_type != 0 {
13            len += 1;
14        }
15        if self.null_bitmap.is_some() {
16            len += 1;
17        }
18        if !self.values.is_empty() {
19            len += 1;
20        }
21        if self.struct_array_data.is_some() {
22            len += 1;
23        }
24        if self.list_array_data.is_some() {
25            len += 1;
26        }
27        let mut struct_ser = serializer.serialize_struct("data.Array", len)?;
28        if self.array_type != 0 {
29            let v = ArrayType::try_from(self.array_type)
30                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.array_type)))?;
31            struct_ser.serialize_field("arrayType", &v)?;
32        }
33        if let Some(v) = self.null_bitmap.as_ref() {
34            struct_ser.serialize_field("nullBitmap", v)?;
35        }
36        if !self.values.is_empty() {
37            struct_ser.serialize_field("values", &self.values)?;
38        }
39        if let Some(v) = self.struct_array_data.as_ref() {
40            struct_ser.serialize_field("structArrayData", v)?;
41        }
42        if let Some(v) = self.list_array_data.as_ref() {
43            struct_ser.serialize_field("listArrayData", v)?;
44        }
45        struct_ser.end()
46    }
47}
48impl<'de> serde::Deserialize<'de> for Array {
49    #[allow(deprecated)]
50    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
51    where
52        D: serde::Deserializer<'de>,
53    {
54        const FIELDS: &[&str] = &[
55            "array_type",
56            "arrayType",
57            "null_bitmap",
58            "nullBitmap",
59            "values",
60            "struct_array_data",
61            "structArrayData",
62            "list_array_data",
63            "listArrayData",
64        ];
65
66        #[allow(clippy::enum_variant_names)]
67        enum GeneratedField {
68            ArrayType,
69            NullBitmap,
70            Values,
71            StructArrayData,
72            ListArrayData,
73        }
74        impl<'de> serde::Deserialize<'de> for GeneratedField {
75            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
76            where
77                D: serde::Deserializer<'de>,
78            {
79                struct GeneratedVisitor;
80
81                impl serde::de::Visitor<'_> for GeneratedVisitor {
82                    type Value = GeneratedField;
83
84                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
85                        write!(formatter, "expected one of: {:?}", &FIELDS)
86                    }
87
88                    #[allow(unused_variables)]
89                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
90                    where
91                        E: serde::de::Error,
92                    {
93                        match value {
94                            "arrayType" | "array_type" => Ok(GeneratedField::ArrayType),
95                            "nullBitmap" | "null_bitmap" => Ok(GeneratedField::NullBitmap),
96                            "values" => Ok(GeneratedField::Values),
97                            "structArrayData" | "struct_array_data" => Ok(GeneratedField::StructArrayData),
98                            "listArrayData" | "list_array_data" => Ok(GeneratedField::ListArrayData),
99                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
100                        }
101                    }
102                }
103                deserializer.deserialize_identifier(GeneratedVisitor)
104            }
105        }
106        struct GeneratedVisitor;
107        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
108            type Value = Array;
109
110            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
111                formatter.write_str("struct data.Array")
112            }
113
114            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Array, V::Error>
115                where
116                    V: serde::de::MapAccess<'de>,
117            {
118                let mut array_type__ = None;
119                let mut null_bitmap__ = None;
120                let mut values__ = None;
121                let mut struct_array_data__ = None;
122                let mut list_array_data__ = None;
123                while let Some(k) = map_.next_key()? {
124                    match k {
125                        GeneratedField::ArrayType => {
126                            if array_type__.is_some() {
127                                return Err(serde::de::Error::duplicate_field("arrayType"));
128                            }
129                            array_type__ = Some(map_.next_value::<ArrayType>()? as i32);
130                        }
131                        GeneratedField::NullBitmap => {
132                            if null_bitmap__.is_some() {
133                                return Err(serde::de::Error::duplicate_field("nullBitmap"));
134                            }
135                            null_bitmap__ = map_.next_value()?;
136                        }
137                        GeneratedField::Values => {
138                            if values__.is_some() {
139                                return Err(serde::de::Error::duplicate_field("values"));
140                            }
141                            values__ = Some(map_.next_value()?);
142                        }
143                        GeneratedField::StructArrayData => {
144                            if struct_array_data__.is_some() {
145                                return Err(serde::de::Error::duplicate_field("structArrayData"));
146                            }
147                            struct_array_data__ = map_.next_value()?;
148                        }
149                        GeneratedField::ListArrayData => {
150                            if list_array_data__.is_some() {
151                                return Err(serde::de::Error::duplicate_field("listArrayData"));
152                            }
153                            list_array_data__ = map_.next_value()?;
154                        }
155                    }
156                }
157                Ok(Array {
158                    array_type: array_type__.unwrap_or_default(),
159                    null_bitmap: null_bitmap__,
160                    values: values__.unwrap_or_default(),
161                    struct_array_data: struct_array_data__,
162                    list_array_data: list_array_data__,
163                })
164            }
165        }
166        deserializer.deserialize_struct("data.Array", FIELDS, GeneratedVisitor)
167    }
168}
169impl serde::Serialize for ArrayType {
170    #[allow(deprecated)]
171    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
172    where
173        S: serde::Serializer,
174    {
175        let variant = match self {
176            Self::Unspecified => "UNSPECIFIED",
177            Self::Int16 => "INT16",
178            Self::Int32 => "INT32",
179            Self::Int64 => "INT64",
180            Self::Float32 => "FLOAT32",
181            Self::Float64 => "FLOAT64",
182            Self::Utf8 => "UTF8",
183            Self::Bool => "BOOL",
184            Self::Decimal => "DECIMAL",
185            Self::Date => "DATE",
186            Self::Time => "TIME",
187            Self::Timestamp => "TIMESTAMP",
188            Self::Timestamptz => "TIMESTAMPTZ",
189            Self::Interval => "INTERVAL",
190            Self::Struct => "STRUCT",
191            Self::List => "LIST",
192            Self::Bytea => "BYTEA",
193            Self::Jsonb => "JSONB",
194            Self::Serial => "SERIAL",
195            Self::Int256 => "INT256",
196            Self::Map => "MAP",
197            Self::Vector => "VECTOR",
198            Self::Variant => "VARIANT",
199        };
200        serializer.serialize_str(variant)
201    }
202}
203impl<'de> serde::Deserialize<'de> for ArrayType {
204    #[allow(deprecated)]
205    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
206    where
207        D: serde::Deserializer<'de>,
208    {
209        const FIELDS: &[&str] = &[
210            "UNSPECIFIED",
211            "INT16",
212            "INT32",
213            "INT64",
214            "FLOAT32",
215            "FLOAT64",
216            "UTF8",
217            "BOOL",
218            "DECIMAL",
219            "DATE",
220            "TIME",
221            "TIMESTAMP",
222            "TIMESTAMPTZ",
223            "INTERVAL",
224            "STRUCT",
225            "LIST",
226            "BYTEA",
227            "JSONB",
228            "SERIAL",
229            "INT256",
230            "MAP",
231            "VECTOR",
232            "VARIANT",
233        ];
234
235        struct GeneratedVisitor;
236
237        impl serde::de::Visitor<'_> for GeneratedVisitor {
238            type Value = ArrayType;
239
240            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
241                write!(formatter, "expected one of: {:?}", &FIELDS)
242            }
243
244            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
245            where
246                E: serde::de::Error,
247            {
248                i32::try_from(v)
249                    .ok()
250                    .and_then(|x| x.try_into().ok())
251                    .ok_or_else(|| {
252                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
253                    })
254            }
255
256            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
257            where
258                E: serde::de::Error,
259            {
260                i32::try_from(v)
261                    .ok()
262                    .and_then(|x| x.try_into().ok())
263                    .ok_or_else(|| {
264                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
265                    })
266            }
267
268            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
269            where
270                E: serde::de::Error,
271            {
272                match value {
273                    "UNSPECIFIED" => Ok(ArrayType::Unspecified),
274                    "INT16" => Ok(ArrayType::Int16),
275                    "INT32" => Ok(ArrayType::Int32),
276                    "INT64" => Ok(ArrayType::Int64),
277                    "FLOAT32" => Ok(ArrayType::Float32),
278                    "FLOAT64" => Ok(ArrayType::Float64),
279                    "UTF8" => Ok(ArrayType::Utf8),
280                    "BOOL" => Ok(ArrayType::Bool),
281                    "DECIMAL" => Ok(ArrayType::Decimal),
282                    "DATE" => Ok(ArrayType::Date),
283                    "TIME" => Ok(ArrayType::Time),
284                    "TIMESTAMP" => Ok(ArrayType::Timestamp),
285                    "TIMESTAMPTZ" => Ok(ArrayType::Timestamptz),
286                    "INTERVAL" => Ok(ArrayType::Interval),
287                    "STRUCT" => Ok(ArrayType::Struct),
288                    "LIST" => Ok(ArrayType::List),
289                    "BYTEA" => Ok(ArrayType::Bytea),
290                    "JSONB" => Ok(ArrayType::Jsonb),
291                    "SERIAL" => Ok(ArrayType::Serial),
292                    "INT256" => Ok(ArrayType::Int256),
293                    "MAP" => Ok(ArrayType::Map),
294                    "VECTOR" => Ok(ArrayType::Vector),
295                    "VARIANT" => Ok(ArrayType::Variant),
296                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
297                }
298            }
299        }
300        deserializer.deserialize_any(GeneratedVisitor)
301    }
302}
303impl serde::Serialize for DataChunk {
304    #[allow(deprecated)]
305    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
306    where
307        S: serde::Serializer,
308    {
309        use serde::ser::SerializeStruct;
310        let mut len = 0;
311        if self.cardinality != 0 {
312            len += 1;
313        }
314        if !self.columns.is_empty() {
315            len += 1;
316        }
317        let mut struct_ser = serializer.serialize_struct("data.DataChunk", len)?;
318        if self.cardinality != 0 {
319            struct_ser.serialize_field("cardinality", &self.cardinality)?;
320        }
321        if !self.columns.is_empty() {
322            struct_ser.serialize_field("columns", &self.columns)?;
323        }
324        struct_ser.end()
325    }
326}
327impl<'de> serde::Deserialize<'de> for DataChunk {
328    #[allow(deprecated)]
329    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
330    where
331        D: serde::Deserializer<'de>,
332    {
333        const FIELDS: &[&str] = &[
334            "cardinality",
335            "columns",
336        ];
337
338        #[allow(clippy::enum_variant_names)]
339        enum GeneratedField {
340            Cardinality,
341            Columns,
342        }
343        impl<'de> serde::Deserialize<'de> for GeneratedField {
344            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
345            where
346                D: serde::Deserializer<'de>,
347            {
348                struct GeneratedVisitor;
349
350                impl serde::de::Visitor<'_> for GeneratedVisitor {
351                    type Value = GeneratedField;
352
353                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
354                        write!(formatter, "expected one of: {:?}", &FIELDS)
355                    }
356
357                    #[allow(unused_variables)]
358                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
359                    where
360                        E: serde::de::Error,
361                    {
362                        match value {
363                            "cardinality" => Ok(GeneratedField::Cardinality),
364                            "columns" => Ok(GeneratedField::Columns),
365                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
366                        }
367                    }
368                }
369                deserializer.deserialize_identifier(GeneratedVisitor)
370            }
371        }
372        struct GeneratedVisitor;
373        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
374            type Value = DataChunk;
375
376            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
377                formatter.write_str("struct data.DataChunk")
378            }
379
380            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DataChunk, V::Error>
381                where
382                    V: serde::de::MapAccess<'de>,
383            {
384                let mut cardinality__ = None;
385                let mut columns__ = None;
386                while let Some(k) = map_.next_key()? {
387                    match k {
388                        GeneratedField::Cardinality => {
389                            if cardinality__.is_some() {
390                                return Err(serde::de::Error::duplicate_field("cardinality"));
391                            }
392                            cardinality__ = 
393                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
394                            ;
395                        }
396                        GeneratedField::Columns => {
397                            if columns__.is_some() {
398                                return Err(serde::de::Error::duplicate_field("columns"));
399                            }
400                            columns__ = Some(map_.next_value()?);
401                        }
402                    }
403                }
404                Ok(DataChunk {
405                    cardinality: cardinality__.unwrap_or_default(),
406                    columns: columns__.unwrap_or_default(),
407                })
408            }
409        }
410        deserializer.deserialize_struct("data.DataChunk", FIELDS, GeneratedVisitor)
411    }
412}
413impl serde::Serialize for DataType {
414    #[allow(deprecated)]
415    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
416    where
417        S: serde::Serializer,
418    {
419        use serde::ser::SerializeStruct;
420        let mut len = 0;
421        if self.type_name != 0 {
422            len += 1;
423        }
424        if self.precision != 0 {
425            len += 1;
426        }
427        if self.scale != 0 {
428            len += 1;
429        }
430        if self.is_nullable {
431            len += 1;
432        }
433        if self.interval_type != 0 {
434            len += 1;
435        }
436        if !self.field_type.is_empty() {
437            len += 1;
438        }
439        if !self.field_names.is_empty() {
440            len += 1;
441        }
442        if !self.field_ids.is_empty() {
443            len += 1;
444        }
445        let mut struct_ser = serializer.serialize_struct("data.DataType", len)?;
446        if self.type_name != 0 {
447            let v = data_type::TypeName::try_from(self.type_name)
448                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.type_name)))?;
449            struct_ser.serialize_field("typeName", &v)?;
450        }
451        if self.precision != 0 {
452            struct_ser.serialize_field("precision", &self.precision)?;
453        }
454        if self.scale != 0 {
455            struct_ser.serialize_field("scale", &self.scale)?;
456        }
457        if self.is_nullable {
458            struct_ser.serialize_field("isNullable", &self.is_nullable)?;
459        }
460        if self.interval_type != 0 {
461            let v = data_type::IntervalType::try_from(self.interval_type)
462                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.interval_type)))?;
463            struct_ser.serialize_field("intervalType", &v)?;
464        }
465        if !self.field_type.is_empty() {
466            struct_ser.serialize_field("fieldType", &self.field_type)?;
467        }
468        if !self.field_names.is_empty() {
469            struct_ser.serialize_field("fieldNames", &self.field_names)?;
470        }
471        if !self.field_ids.is_empty() {
472            struct_ser.serialize_field("fieldIds", &self.field_ids)?;
473        }
474        struct_ser.end()
475    }
476}
477impl<'de> serde::Deserialize<'de> for DataType {
478    #[allow(deprecated)]
479    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
480    where
481        D: serde::Deserializer<'de>,
482    {
483        const FIELDS: &[&str] = &[
484            "type_name",
485            "typeName",
486            "precision",
487            "scale",
488            "is_nullable",
489            "isNullable",
490            "interval_type",
491            "intervalType",
492            "field_type",
493            "fieldType",
494            "field_names",
495            "fieldNames",
496            "field_ids",
497            "fieldIds",
498        ];
499
500        #[allow(clippy::enum_variant_names)]
501        enum GeneratedField {
502            TypeName,
503            Precision,
504            Scale,
505            IsNullable,
506            IntervalType,
507            FieldType,
508            FieldNames,
509            FieldIds,
510        }
511        impl<'de> serde::Deserialize<'de> for GeneratedField {
512            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
513            where
514                D: serde::Deserializer<'de>,
515            {
516                struct GeneratedVisitor;
517
518                impl serde::de::Visitor<'_> for GeneratedVisitor {
519                    type Value = GeneratedField;
520
521                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
522                        write!(formatter, "expected one of: {:?}", &FIELDS)
523                    }
524
525                    #[allow(unused_variables)]
526                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
527                    where
528                        E: serde::de::Error,
529                    {
530                        match value {
531                            "typeName" | "type_name" => Ok(GeneratedField::TypeName),
532                            "precision" => Ok(GeneratedField::Precision),
533                            "scale" => Ok(GeneratedField::Scale),
534                            "isNullable" | "is_nullable" => Ok(GeneratedField::IsNullable),
535                            "intervalType" | "interval_type" => Ok(GeneratedField::IntervalType),
536                            "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
537                            "fieldNames" | "field_names" => Ok(GeneratedField::FieldNames),
538                            "fieldIds" | "field_ids" => Ok(GeneratedField::FieldIds),
539                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
540                        }
541                    }
542                }
543                deserializer.deserialize_identifier(GeneratedVisitor)
544            }
545        }
546        struct GeneratedVisitor;
547        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
548            type Value = DataType;
549
550            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
551                formatter.write_str("struct data.DataType")
552            }
553
554            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DataType, V::Error>
555                where
556                    V: serde::de::MapAccess<'de>,
557            {
558                let mut type_name__ = None;
559                let mut precision__ = None;
560                let mut scale__ = None;
561                let mut is_nullable__ = None;
562                let mut interval_type__ = None;
563                let mut field_type__ = None;
564                let mut field_names__ = None;
565                let mut field_ids__ = None;
566                while let Some(k) = map_.next_key()? {
567                    match k {
568                        GeneratedField::TypeName => {
569                            if type_name__.is_some() {
570                                return Err(serde::de::Error::duplicate_field("typeName"));
571                            }
572                            type_name__ = Some(map_.next_value::<data_type::TypeName>()? as i32);
573                        }
574                        GeneratedField::Precision => {
575                            if precision__.is_some() {
576                                return Err(serde::de::Error::duplicate_field("precision"));
577                            }
578                            precision__ = 
579                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
580                            ;
581                        }
582                        GeneratedField::Scale => {
583                            if scale__.is_some() {
584                                return Err(serde::de::Error::duplicate_field("scale"));
585                            }
586                            scale__ = 
587                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
588                            ;
589                        }
590                        GeneratedField::IsNullable => {
591                            if is_nullable__.is_some() {
592                                return Err(serde::de::Error::duplicate_field("isNullable"));
593                            }
594                            is_nullable__ = Some(map_.next_value()?);
595                        }
596                        GeneratedField::IntervalType => {
597                            if interval_type__.is_some() {
598                                return Err(serde::de::Error::duplicate_field("intervalType"));
599                            }
600                            interval_type__ = Some(map_.next_value::<data_type::IntervalType>()? as i32);
601                        }
602                        GeneratedField::FieldType => {
603                            if field_type__.is_some() {
604                                return Err(serde::de::Error::duplicate_field("fieldType"));
605                            }
606                            field_type__ = Some(map_.next_value()?);
607                        }
608                        GeneratedField::FieldNames => {
609                            if field_names__.is_some() {
610                                return Err(serde::de::Error::duplicate_field("fieldNames"));
611                            }
612                            field_names__ = Some(map_.next_value()?);
613                        }
614                        GeneratedField::FieldIds => {
615                            if field_ids__.is_some() {
616                                return Err(serde::de::Error::duplicate_field("fieldIds"));
617                            }
618                            field_ids__ = 
619                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
620                                    .into_iter().map(|x| x.0).collect())
621                            ;
622                        }
623                    }
624                }
625                Ok(DataType {
626                    type_name: type_name__.unwrap_or_default(),
627                    precision: precision__.unwrap_or_default(),
628                    scale: scale__.unwrap_or_default(),
629                    is_nullable: is_nullable__.unwrap_or_default(),
630                    interval_type: interval_type__.unwrap_or_default(),
631                    field_type: field_type__.unwrap_or_default(),
632                    field_names: field_names__.unwrap_or_default(),
633                    field_ids: field_ids__.unwrap_or_default(),
634                })
635            }
636        }
637        deserializer.deserialize_struct("data.DataType", FIELDS, GeneratedVisitor)
638    }
639}
640impl serde::Serialize for data_type::IntervalType {
641    #[allow(deprecated)]
642    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
643    where
644        S: serde::Serializer,
645    {
646        let variant = match self {
647            Self::Unspecified => "UNSPECIFIED",
648            Self::Year => "YEAR",
649            Self::Month => "MONTH",
650            Self::Day => "DAY",
651            Self::Hour => "HOUR",
652            Self::Minute => "MINUTE",
653            Self::Second => "SECOND",
654            Self::YearToMonth => "YEAR_TO_MONTH",
655            Self::DayToHour => "DAY_TO_HOUR",
656            Self::DayToMinute => "DAY_TO_MINUTE",
657            Self::DayToSecond => "DAY_TO_SECOND",
658            Self::HourToMinute => "HOUR_TO_MINUTE",
659            Self::HourToSecond => "HOUR_TO_SECOND",
660            Self::MinuteToSecond => "MINUTE_TO_SECOND",
661        };
662        serializer.serialize_str(variant)
663    }
664}
665impl<'de> serde::Deserialize<'de> for data_type::IntervalType {
666    #[allow(deprecated)]
667    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
668    where
669        D: serde::Deserializer<'de>,
670    {
671        const FIELDS: &[&str] = &[
672            "UNSPECIFIED",
673            "YEAR",
674            "MONTH",
675            "DAY",
676            "HOUR",
677            "MINUTE",
678            "SECOND",
679            "YEAR_TO_MONTH",
680            "DAY_TO_HOUR",
681            "DAY_TO_MINUTE",
682            "DAY_TO_SECOND",
683            "HOUR_TO_MINUTE",
684            "HOUR_TO_SECOND",
685            "MINUTE_TO_SECOND",
686        ];
687
688        struct GeneratedVisitor;
689
690        impl serde::de::Visitor<'_> for GeneratedVisitor {
691            type Value = data_type::IntervalType;
692
693            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
694                write!(formatter, "expected one of: {:?}", &FIELDS)
695            }
696
697            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
698            where
699                E: serde::de::Error,
700            {
701                i32::try_from(v)
702                    .ok()
703                    .and_then(|x| x.try_into().ok())
704                    .ok_or_else(|| {
705                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
706                    })
707            }
708
709            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
710            where
711                E: serde::de::Error,
712            {
713                i32::try_from(v)
714                    .ok()
715                    .and_then(|x| x.try_into().ok())
716                    .ok_or_else(|| {
717                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
718                    })
719            }
720
721            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
722            where
723                E: serde::de::Error,
724            {
725                match value {
726                    "UNSPECIFIED" => Ok(data_type::IntervalType::Unspecified),
727                    "YEAR" => Ok(data_type::IntervalType::Year),
728                    "MONTH" => Ok(data_type::IntervalType::Month),
729                    "DAY" => Ok(data_type::IntervalType::Day),
730                    "HOUR" => Ok(data_type::IntervalType::Hour),
731                    "MINUTE" => Ok(data_type::IntervalType::Minute),
732                    "SECOND" => Ok(data_type::IntervalType::Second),
733                    "YEAR_TO_MONTH" => Ok(data_type::IntervalType::YearToMonth),
734                    "DAY_TO_HOUR" => Ok(data_type::IntervalType::DayToHour),
735                    "DAY_TO_MINUTE" => Ok(data_type::IntervalType::DayToMinute),
736                    "DAY_TO_SECOND" => Ok(data_type::IntervalType::DayToSecond),
737                    "HOUR_TO_MINUTE" => Ok(data_type::IntervalType::HourToMinute),
738                    "HOUR_TO_SECOND" => Ok(data_type::IntervalType::HourToSecond),
739                    "MINUTE_TO_SECOND" => Ok(data_type::IntervalType::MinuteToSecond),
740                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
741                }
742            }
743        }
744        deserializer.deserialize_any(GeneratedVisitor)
745    }
746}
747impl serde::Serialize for data_type::TypeName {
748    #[allow(deprecated)]
749    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
750    where
751        S: serde::Serializer,
752    {
753        let variant = match self {
754            Self::TypeUnspecified => "TYPE_UNSPECIFIED",
755            Self::Int16 => "INT16",
756            Self::Int32 => "INT32",
757            Self::Int64 => "INT64",
758            Self::Float => "FLOAT",
759            Self::Double => "DOUBLE",
760            Self::Boolean => "BOOLEAN",
761            Self::Varchar => "VARCHAR",
762            Self::Decimal => "DECIMAL",
763            Self::Time => "TIME",
764            Self::Timestamp => "TIMESTAMP",
765            Self::Interval => "INTERVAL",
766            Self::Date => "DATE",
767            Self::Timestamptz => "TIMESTAMPTZ",
768            Self::Struct => "STRUCT",
769            Self::List => "LIST",
770            Self::Bytea => "BYTEA",
771            Self::Jsonb => "JSONB",
772            Self::Serial => "SERIAL",
773            Self::Int256 => "INT256",
774            Self::Map => "MAP",
775            Self::Vector => "VECTOR",
776            Self::Variant => "VARIANT",
777        };
778        serializer.serialize_str(variant)
779    }
780}
781impl<'de> serde::Deserialize<'de> for data_type::TypeName {
782    #[allow(deprecated)]
783    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
784    where
785        D: serde::Deserializer<'de>,
786    {
787        const FIELDS: &[&str] = &[
788            "TYPE_UNSPECIFIED",
789            "INT16",
790            "INT32",
791            "INT64",
792            "FLOAT",
793            "DOUBLE",
794            "BOOLEAN",
795            "VARCHAR",
796            "DECIMAL",
797            "TIME",
798            "TIMESTAMP",
799            "INTERVAL",
800            "DATE",
801            "TIMESTAMPTZ",
802            "STRUCT",
803            "LIST",
804            "BYTEA",
805            "JSONB",
806            "SERIAL",
807            "INT256",
808            "MAP",
809            "VECTOR",
810            "VARIANT",
811        ];
812
813        struct GeneratedVisitor;
814
815        impl serde::de::Visitor<'_> for GeneratedVisitor {
816            type Value = data_type::TypeName;
817
818            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
819                write!(formatter, "expected one of: {:?}", &FIELDS)
820            }
821
822            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
823            where
824                E: serde::de::Error,
825            {
826                i32::try_from(v)
827                    .ok()
828                    .and_then(|x| x.try_into().ok())
829                    .ok_or_else(|| {
830                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
831                    })
832            }
833
834            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
835            where
836                E: serde::de::Error,
837            {
838                i32::try_from(v)
839                    .ok()
840                    .and_then(|x| x.try_into().ok())
841                    .ok_or_else(|| {
842                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
843                    })
844            }
845
846            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
847            where
848                E: serde::de::Error,
849            {
850                match value {
851                    "TYPE_UNSPECIFIED" => Ok(data_type::TypeName::TypeUnspecified),
852                    "INT16" => Ok(data_type::TypeName::Int16),
853                    "INT32" => Ok(data_type::TypeName::Int32),
854                    "INT64" => Ok(data_type::TypeName::Int64),
855                    "FLOAT" => Ok(data_type::TypeName::Float),
856                    "DOUBLE" => Ok(data_type::TypeName::Double),
857                    "BOOLEAN" => Ok(data_type::TypeName::Boolean),
858                    "VARCHAR" => Ok(data_type::TypeName::Varchar),
859                    "DECIMAL" => Ok(data_type::TypeName::Decimal),
860                    "TIME" => Ok(data_type::TypeName::Time),
861                    "TIMESTAMP" => Ok(data_type::TypeName::Timestamp),
862                    "INTERVAL" => Ok(data_type::TypeName::Interval),
863                    "DATE" => Ok(data_type::TypeName::Date),
864                    "TIMESTAMPTZ" => Ok(data_type::TypeName::Timestamptz),
865                    "STRUCT" => Ok(data_type::TypeName::Struct),
866                    "LIST" => Ok(data_type::TypeName::List),
867                    "BYTEA" => Ok(data_type::TypeName::Bytea),
868                    "JSONB" => Ok(data_type::TypeName::Jsonb),
869                    "SERIAL" => Ok(data_type::TypeName::Serial),
870                    "INT256" => Ok(data_type::TypeName::Int256),
871                    "MAP" => Ok(data_type::TypeName::Map),
872                    "VECTOR" => Ok(data_type::TypeName::Vector),
873                    "VARIANT" => Ok(data_type::TypeName::Variant),
874                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
875                }
876            }
877        }
878        deserializer.deserialize_any(GeneratedVisitor)
879    }
880}
881impl serde::Serialize for Datum {
882    #[allow(deprecated)]
883    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
884    where
885        S: serde::Serializer,
886    {
887        use serde::ser::SerializeStruct;
888        let mut len = 0;
889        if !self.body.is_empty() {
890            len += 1;
891        }
892        let mut struct_ser = serializer.serialize_struct("data.Datum", len)?;
893        if !self.body.is_empty() {
894            #[allow(clippy::needless_borrow)]
895            #[allow(clippy::needless_borrows_for_generic_args)]
896            struct_ser.serialize_field("body", pbjson::private::base64::encode(&self.body).as_str())?;
897        }
898        struct_ser.end()
899    }
900}
901impl<'de> serde::Deserialize<'de> for Datum {
902    #[allow(deprecated)]
903    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
904    where
905        D: serde::Deserializer<'de>,
906    {
907        const FIELDS: &[&str] = &[
908            "body",
909        ];
910
911        #[allow(clippy::enum_variant_names)]
912        enum GeneratedField {
913            Body,
914        }
915        impl<'de> serde::Deserialize<'de> for GeneratedField {
916            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
917            where
918                D: serde::Deserializer<'de>,
919            {
920                struct GeneratedVisitor;
921
922                impl serde::de::Visitor<'_> for GeneratedVisitor {
923                    type Value = GeneratedField;
924
925                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
926                        write!(formatter, "expected one of: {:?}", &FIELDS)
927                    }
928
929                    #[allow(unused_variables)]
930                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
931                    where
932                        E: serde::de::Error,
933                    {
934                        match value {
935                            "body" => Ok(GeneratedField::Body),
936                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
937                        }
938                    }
939                }
940                deserializer.deserialize_identifier(GeneratedVisitor)
941            }
942        }
943        struct GeneratedVisitor;
944        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
945            type Value = Datum;
946
947            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
948                formatter.write_str("struct data.Datum")
949            }
950
951            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Datum, V::Error>
952                where
953                    V: serde::de::MapAccess<'de>,
954            {
955                let mut body__ = None;
956                while let Some(k) = map_.next_key()? {
957                    match k {
958                        GeneratedField::Body => {
959                            if body__.is_some() {
960                                return Err(serde::de::Error::duplicate_field("body"));
961                            }
962                            body__ = 
963                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
964                            ;
965                        }
966                    }
967                }
968                Ok(Datum {
969                    body: body__.unwrap_or_default(),
970                })
971            }
972        }
973        deserializer.deserialize_struct("data.Datum", FIELDS, GeneratedVisitor)
974    }
975}
976impl serde::Serialize for Epoch {
977    #[allow(deprecated)]
978    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
979    where
980        S: serde::Serializer,
981    {
982        use serde::ser::SerializeStruct;
983        let mut len = 0;
984        if self.curr != 0 {
985            len += 1;
986        }
987        if self.prev != 0 {
988            len += 1;
989        }
990        let mut struct_ser = serializer.serialize_struct("data.Epoch", len)?;
991        if self.curr != 0 {
992            #[allow(clippy::needless_borrow)]
993            #[allow(clippy::needless_borrows_for_generic_args)]
994            struct_ser.serialize_field("curr", ToString::to_string(&self.curr).as_str())?;
995        }
996        if self.prev != 0 {
997            #[allow(clippy::needless_borrow)]
998            #[allow(clippy::needless_borrows_for_generic_args)]
999            struct_ser.serialize_field("prev", ToString::to_string(&self.prev).as_str())?;
1000        }
1001        struct_ser.end()
1002    }
1003}
1004impl<'de> serde::Deserialize<'de> for Epoch {
1005    #[allow(deprecated)]
1006    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1007    where
1008        D: serde::Deserializer<'de>,
1009    {
1010        const FIELDS: &[&str] = &[
1011            "curr",
1012            "prev",
1013        ];
1014
1015        #[allow(clippy::enum_variant_names)]
1016        enum GeneratedField {
1017            Curr,
1018            Prev,
1019        }
1020        impl<'de> serde::Deserialize<'de> for GeneratedField {
1021            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1022            where
1023                D: serde::Deserializer<'de>,
1024            {
1025                struct GeneratedVisitor;
1026
1027                impl serde::de::Visitor<'_> for GeneratedVisitor {
1028                    type Value = GeneratedField;
1029
1030                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1031                        write!(formatter, "expected one of: {:?}", &FIELDS)
1032                    }
1033
1034                    #[allow(unused_variables)]
1035                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1036                    where
1037                        E: serde::de::Error,
1038                    {
1039                        match value {
1040                            "curr" => Ok(GeneratedField::Curr),
1041                            "prev" => Ok(GeneratedField::Prev),
1042                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1043                        }
1044                    }
1045                }
1046                deserializer.deserialize_identifier(GeneratedVisitor)
1047            }
1048        }
1049        struct GeneratedVisitor;
1050        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1051            type Value = Epoch;
1052
1053            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1054                formatter.write_str("struct data.Epoch")
1055            }
1056
1057            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Epoch, V::Error>
1058                where
1059                    V: serde::de::MapAccess<'de>,
1060            {
1061                let mut curr__ = None;
1062                let mut prev__ = None;
1063                while let Some(k) = map_.next_key()? {
1064                    match k {
1065                        GeneratedField::Curr => {
1066                            if curr__.is_some() {
1067                                return Err(serde::de::Error::duplicate_field("curr"));
1068                            }
1069                            curr__ = 
1070                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1071                            ;
1072                        }
1073                        GeneratedField::Prev => {
1074                            if prev__.is_some() {
1075                                return Err(serde::de::Error::duplicate_field("prev"));
1076                            }
1077                            prev__ = 
1078                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1079                            ;
1080                        }
1081                    }
1082                }
1083                Ok(Epoch {
1084                    curr: curr__.unwrap_or_default(),
1085                    prev: prev__.unwrap_or_default(),
1086                })
1087            }
1088        }
1089        deserializer.deserialize_struct("data.Epoch", FIELDS, GeneratedVisitor)
1090    }
1091}
1092impl serde::Serialize for Interval {
1093    #[allow(deprecated)]
1094    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1095    where
1096        S: serde::Serializer,
1097    {
1098        use serde::ser::SerializeStruct;
1099        let mut len = 0;
1100        if self.months != 0 {
1101            len += 1;
1102        }
1103        if self.days != 0 {
1104            len += 1;
1105        }
1106        if self.usecs != 0 {
1107            len += 1;
1108        }
1109        let mut struct_ser = serializer.serialize_struct("data.Interval", len)?;
1110        if self.months != 0 {
1111            struct_ser.serialize_field("months", &self.months)?;
1112        }
1113        if self.days != 0 {
1114            struct_ser.serialize_field("days", &self.days)?;
1115        }
1116        if self.usecs != 0 {
1117            #[allow(clippy::needless_borrow)]
1118            #[allow(clippy::needless_borrows_for_generic_args)]
1119            struct_ser.serialize_field("usecs", ToString::to_string(&self.usecs).as_str())?;
1120        }
1121        struct_ser.end()
1122    }
1123}
1124impl<'de> serde::Deserialize<'de> for Interval {
1125    #[allow(deprecated)]
1126    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1127    where
1128        D: serde::Deserializer<'de>,
1129    {
1130        const FIELDS: &[&str] = &[
1131            "months",
1132            "days",
1133            "usecs",
1134        ];
1135
1136        #[allow(clippy::enum_variant_names)]
1137        enum GeneratedField {
1138            Months,
1139            Days,
1140            Usecs,
1141        }
1142        impl<'de> serde::Deserialize<'de> for GeneratedField {
1143            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1144            where
1145                D: serde::Deserializer<'de>,
1146            {
1147                struct GeneratedVisitor;
1148
1149                impl serde::de::Visitor<'_> for GeneratedVisitor {
1150                    type Value = GeneratedField;
1151
1152                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1153                        write!(formatter, "expected one of: {:?}", &FIELDS)
1154                    }
1155
1156                    #[allow(unused_variables)]
1157                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1158                    where
1159                        E: serde::de::Error,
1160                    {
1161                        match value {
1162                            "months" => Ok(GeneratedField::Months),
1163                            "days" => Ok(GeneratedField::Days),
1164                            "usecs" => Ok(GeneratedField::Usecs),
1165                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1166                        }
1167                    }
1168                }
1169                deserializer.deserialize_identifier(GeneratedVisitor)
1170            }
1171        }
1172        struct GeneratedVisitor;
1173        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1174            type Value = Interval;
1175
1176            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1177                formatter.write_str("struct data.Interval")
1178            }
1179
1180            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Interval, V::Error>
1181                where
1182                    V: serde::de::MapAccess<'de>,
1183            {
1184                let mut months__ = None;
1185                let mut days__ = None;
1186                let mut usecs__ = None;
1187                while let Some(k) = map_.next_key()? {
1188                    match k {
1189                        GeneratedField::Months => {
1190                            if months__.is_some() {
1191                                return Err(serde::de::Error::duplicate_field("months"));
1192                            }
1193                            months__ = 
1194                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1195                            ;
1196                        }
1197                        GeneratedField::Days => {
1198                            if days__.is_some() {
1199                                return Err(serde::de::Error::duplicate_field("days"));
1200                            }
1201                            days__ = 
1202                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1203                            ;
1204                        }
1205                        GeneratedField::Usecs => {
1206                            if usecs__.is_some() {
1207                                return Err(serde::de::Error::duplicate_field("usecs"));
1208                            }
1209                            usecs__ = 
1210                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1211                            ;
1212                        }
1213                    }
1214                }
1215                Ok(Interval {
1216                    months: months__.unwrap_or_default(),
1217                    days: days__.unwrap_or_default(),
1218                    usecs: usecs__.unwrap_or_default(),
1219                })
1220            }
1221        }
1222        deserializer.deserialize_struct("data.Interval", FIELDS, GeneratedVisitor)
1223    }
1224}
1225impl serde::Serialize for ListArrayData {
1226    #[allow(deprecated)]
1227    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1228    where
1229        S: serde::Serializer,
1230    {
1231        use serde::ser::SerializeStruct;
1232        let mut len = 0;
1233        if !self.offsets.is_empty() {
1234            len += 1;
1235        }
1236        if self.value.is_some() {
1237            len += 1;
1238        }
1239        if self.value_type.is_some() {
1240            len += 1;
1241        }
1242        if self.elem_size.is_some() {
1243            len += 1;
1244        }
1245        let mut struct_ser = serializer.serialize_struct("data.ListArrayData", len)?;
1246        if !self.offsets.is_empty() {
1247            struct_ser.serialize_field("offsets", &self.offsets)?;
1248        }
1249        if let Some(v) = self.value.as_ref() {
1250            struct_ser.serialize_field("value", v)?;
1251        }
1252        if let Some(v) = self.value_type.as_ref() {
1253            struct_ser.serialize_field("valueType", v)?;
1254        }
1255        if let Some(v) = self.elem_size.as_ref() {
1256            struct_ser.serialize_field("elemSize", v)?;
1257        }
1258        struct_ser.end()
1259    }
1260}
1261impl<'de> serde::Deserialize<'de> for ListArrayData {
1262    #[allow(deprecated)]
1263    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1264    where
1265        D: serde::Deserializer<'de>,
1266    {
1267        const FIELDS: &[&str] = &[
1268            "offsets",
1269            "value",
1270            "value_type",
1271            "valueType",
1272            "elem_size",
1273            "elemSize",
1274        ];
1275
1276        #[allow(clippy::enum_variant_names)]
1277        enum GeneratedField {
1278            Offsets,
1279            Value,
1280            ValueType,
1281            ElemSize,
1282        }
1283        impl<'de> serde::Deserialize<'de> for GeneratedField {
1284            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1285            where
1286                D: serde::Deserializer<'de>,
1287            {
1288                struct GeneratedVisitor;
1289
1290                impl serde::de::Visitor<'_> for GeneratedVisitor {
1291                    type Value = GeneratedField;
1292
1293                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1294                        write!(formatter, "expected one of: {:?}", &FIELDS)
1295                    }
1296
1297                    #[allow(unused_variables)]
1298                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1299                    where
1300                        E: serde::de::Error,
1301                    {
1302                        match value {
1303                            "offsets" => Ok(GeneratedField::Offsets),
1304                            "value" => Ok(GeneratedField::Value),
1305                            "valueType" | "value_type" => Ok(GeneratedField::ValueType),
1306                            "elemSize" | "elem_size" => Ok(GeneratedField::ElemSize),
1307                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1308                        }
1309                    }
1310                }
1311                deserializer.deserialize_identifier(GeneratedVisitor)
1312            }
1313        }
1314        struct GeneratedVisitor;
1315        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1316            type Value = ListArrayData;
1317
1318            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1319                formatter.write_str("struct data.ListArrayData")
1320            }
1321
1322            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListArrayData, V::Error>
1323                where
1324                    V: serde::de::MapAccess<'de>,
1325            {
1326                let mut offsets__ = None;
1327                let mut value__ = None;
1328                let mut value_type__ = None;
1329                let mut elem_size__ = None;
1330                while let Some(k) = map_.next_key()? {
1331                    match k {
1332                        GeneratedField::Offsets => {
1333                            if offsets__.is_some() {
1334                                return Err(serde::de::Error::duplicate_field("offsets"));
1335                            }
1336                            offsets__ = 
1337                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1338                                    .into_iter().map(|x| x.0).collect())
1339                            ;
1340                        }
1341                        GeneratedField::Value => {
1342                            if value__.is_some() {
1343                                return Err(serde::de::Error::duplicate_field("value"));
1344                            }
1345                            value__ = map_.next_value()?;
1346                        }
1347                        GeneratedField::ValueType => {
1348                            if value_type__.is_some() {
1349                                return Err(serde::de::Error::duplicate_field("valueType"));
1350                            }
1351                            value_type__ = map_.next_value()?;
1352                        }
1353                        GeneratedField::ElemSize => {
1354                            if elem_size__.is_some() {
1355                                return Err(serde::de::Error::duplicate_field("elemSize"));
1356                            }
1357                            elem_size__ = 
1358                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1359                            ;
1360                        }
1361                    }
1362                }
1363                Ok(ListArrayData {
1364                    offsets: offsets__.unwrap_or_default(),
1365                    value: value__,
1366                    value_type: value_type__,
1367                    elem_size: elem_size__,
1368                })
1369            }
1370        }
1371        deserializer.deserialize_struct("data.ListArrayData", FIELDS, GeneratedVisitor)
1372    }
1373}
1374impl serde::Serialize for Op {
1375    #[allow(deprecated)]
1376    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1377    where
1378        S: serde::Serializer,
1379    {
1380        let variant = match self {
1381            Self::Unspecified => "OP_UNSPECIFIED",
1382            Self::Insert => "INSERT",
1383            Self::Delete => "DELETE",
1384            Self::UpdateInsert => "UPDATE_INSERT",
1385            Self::UpdateDelete => "UPDATE_DELETE",
1386        };
1387        serializer.serialize_str(variant)
1388    }
1389}
1390impl<'de> serde::Deserialize<'de> for Op {
1391    #[allow(deprecated)]
1392    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1393    where
1394        D: serde::Deserializer<'de>,
1395    {
1396        const FIELDS: &[&str] = &[
1397            "OP_UNSPECIFIED",
1398            "INSERT",
1399            "DELETE",
1400            "UPDATE_INSERT",
1401            "UPDATE_DELETE",
1402        ];
1403
1404        struct GeneratedVisitor;
1405
1406        impl serde::de::Visitor<'_> for GeneratedVisitor {
1407            type Value = Op;
1408
1409            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1410                write!(formatter, "expected one of: {:?}", &FIELDS)
1411            }
1412
1413            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1414            where
1415                E: serde::de::Error,
1416            {
1417                i32::try_from(v)
1418                    .ok()
1419                    .and_then(|x| x.try_into().ok())
1420                    .ok_or_else(|| {
1421                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1422                    })
1423            }
1424
1425            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1426            where
1427                E: serde::de::Error,
1428            {
1429                i32::try_from(v)
1430                    .ok()
1431                    .and_then(|x| x.try_into().ok())
1432                    .ok_or_else(|| {
1433                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1434                    })
1435            }
1436
1437            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1438            where
1439                E: serde::de::Error,
1440            {
1441                match value {
1442                    "OP_UNSPECIFIED" => Ok(Op::Unspecified),
1443                    "INSERT" => Ok(Op::Insert),
1444                    "DELETE" => Ok(Op::Delete),
1445                    "UPDATE_INSERT" => Ok(Op::UpdateInsert),
1446                    "UPDATE_DELETE" => Ok(Op::UpdateDelete),
1447                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1448                }
1449            }
1450        }
1451        deserializer.deserialize_any(GeneratedVisitor)
1452    }
1453}
1454impl serde::Serialize for StreamChunk {
1455    #[allow(deprecated)]
1456    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1457    where
1458        S: serde::Serializer,
1459    {
1460        use serde::ser::SerializeStruct;
1461        let mut len = 0;
1462        if self.cardinality != 0 {
1463            len += 1;
1464        }
1465        if !self.ops.is_empty() {
1466            len += 1;
1467        }
1468        if !self.columns.is_empty() {
1469            len += 1;
1470        }
1471        let mut struct_ser = serializer.serialize_struct("data.StreamChunk", len)?;
1472        if self.cardinality != 0 {
1473            struct_ser.serialize_field("cardinality", &self.cardinality)?;
1474        }
1475        if !self.ops.is_empty() {
1476            let v = self.ops.iter().cloned().map(|v| {
1477                Op::try_from(v)
1478                    .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v)))
1479                }).collect::<std::result::Result<Vec<_>, _>>()?;
1480            struct_ser.serialize_field("ops", &v)?;
1481        }
1482        if !self.columns.is_empty() {
1483            struct_ser.serialize_field("columns", &self.columns)?;
1484        }
1485        struct_ser.end()
1486    }
1487}
1488impl<'de> serde::Deserialize<'de> for StreamChunk {
1489    #[allow(deprecated)]
1490    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1491    where
1492        D: serde::Deserializer<'de>,
1493    {
1494        const FIELDS: &[&str] = &[
1495            "cardinality",
1496            "ops",
1497            "columns",
1498        ];
1499
1500        #[allow(clippy::enum_variant_names)]
1501        enum GeneratedField {
1502            Cardinality,
1503            Ops,
1504            Columns,
1505        }
1506        impl<'de> serde::Deserialize<'de> for GeneratedField {
1507            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1508            where
1509                D: serde::Deserializer<'de>,
1510            {
1511                struct GeneratedVisitor;
1512
1513                impl serde::de::Visitor<'_> for GeneratedVisitor {
1514                    type Value = GeneratedField;
1515
1516                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1517                        write!(formatter, "expected one of: {:?}", &FIELDS)
1518                    }
1519
1520                    #[allow(unused_variables)]
1521                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1522                    where
1523                        E: serde::de::Error,
1524                    {
1525                        match value {
1526                            "cardinality" => Ok(GeneratedField::Cardinality),
1527                            "ops" => Ok(GeneratedField::Ops),
1528                            "columns" => Ok(GeneratedField::Columns),
1529                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1530                        }
1531                    }
1532                }
1533                deserializer.deserialize_identifier(GeneratedVisitor)
1534            }
1535        }
1536        struct GeneratedVisitor;
1537        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1538            type Value = StreamChunk;
1539
1540            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1541                formatter.write_str("struct data.StreamChunk")
1542            }
1543
1544            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamChunk, V::Error>
1545                where
1546                    V: serde::de::MapAccess<'de>,
1547            {
1548                let mut cardinality__ = None;
1549                let mut ops__ = None;
1550                let mut columns__ = None;
1551                while let Some(k) = map_.next_key()? {
1552                    match k {
1553                        GeneratedField::Cardinality => {
1554                            if cardinality__.is_some() {
1555                                return Err(serde::de::Error::duplicate_field("cardinality"));
1556                            }
1557                            cardinality__ = 
1558                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1559                            ;
1560                        }
1561                        GeneratedField::Ops => {
1562                            if ops__.is_some() {
1563                                return Err(serde::de::Error::duplicate_field("ops"));
1564                            }
1565                            ops__ = Some(map_.next_value::<Vec<Op>>()?.into_iter().map(|x| x as i32).collect());
1566                        }
1567                        GeneratedField::Columns => {
1568                            if columns__.is_some() {
1569                                return Err(serde::de::Error::duplicate_field("columns"));
1570                            }
1571                            columns__ = Some(map_.next_value()?);
1572                        }
1573                    }
1574                }
1575                Ok(StreamChunk {
1576                    cardinality: cardinality__.unwrap_or_default(),
1577                    ops: ops__.unwrap_or_default(),
1578                    columns: columns__.unwrap_or_default(),
1579                })
1580            }
1581        }
1582        deserializer.deserialize_struct("data.StreamChunk", FIELDS, GeneratedVisitor)
1583    }
1584}
1585impl serde::Serialize for StructArrayData {
1586    #[allow(deprecated)]
1587    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1588    where
1589        S: serde::Serializer,
1590    {
1591        use serde::ser::SerializeStruct;
1592        let mut len = 0;
1593        if !self.children_array.is_empty() {
1594            len += 1;
1595        }
1596        if !self.children_type.is_empty() {
1597            len += 1;
1598        }
1599        let mut struct_ser = serializer.serialize_struct("data.StructArrayData", len)?;
1600        if !self.children_array.is_empty() {
1601            struct_ser.serialize_field("childrenArray", &self.children_array)?;
1602        }
1603        if !self.children_type.is_empty() {
1604            struct_ser.serialize_field("childrenType", &self.children_type)?;
1605        }
1606        struct_ser.end()
1607    }
1608}
1609impl<'de> serde::Deserialize<'de> for StructArrayData {
1610    #[allow(deprecated)]
1611    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1612    where
1613        D: serde::Deserializer<'de>,
1614    {
1615        const FIELDS: &[&str] = &[
1616            "children_array",
1617            "childrenArray",
1618            "children_type",
1619            "childrenType",
1620        ];
1621
1622        #[allow(clippy::enum_variant_names)]
1623        enum GeneratedField {
1624            ChildrenArray,
1625            ChildrenType,
1626        }
1627        impl<'de> serde::Deserialize<'de> for GeneratedField {
1628            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1629            where
1630                D: serde::Deserializer<'de>,
1631            {
1632                struct GeneratedVisitor;
1633
1634                impl serde::de::Visitor<'_> for GeneratedVisitor {
1635                    type Value = GeneratedField;
1636
1637                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1638                        write!(formatter, "expected one of: {:?}", &FIELDS)
1639                    }
1640
1641                    #[allow(unused_variables)]
1642                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1643                    where
1644                        E: serde::de::Error,
1645                    {
1646                        match value {
1647                            "childrenArray" | "children_array" => Ok(GeneratedField::ChildrenArray),
1648                            "childrenType" | "children_type" => Ok(GeneratedField::ChildrenType),
1649                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1650                        }
1651                    }
1652                }
1653                deserializer.deserialize_identifier(GeneratedVisitor)
1654            }
1655        }
1656        struct GeneratedVisitor;
1657        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1658            type Value = StructArrayData;
1659
1660            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1661                formatter.write_str("struct data.StructArrayData")
1662            }
1663
1664            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StructArrayData, V::Error>
1665                where
1666                    V: serde::de::MapAccess<'de>,
1667            {
1668                let mut children_array__ = None;
1669                let mut children_type__ = None;
1670                while let Some(k) = map_.next_key()? {
1671                    match k {
1672                        GeneratedField::ChildrenArray => {
1673                            if children_array__.is_some() {
1674                                return Err(serde::de::Error::duplicate_field("childrenArray"));
1675                            }
1676                            children_array__ = Some(map_.next_value()?);
1677                        }
1678                        GeneratedField::ChildrenType => {
1679                            if children_type__.is_some() {
1680                                return Err(serde::de::Error::duplicate_field("childrenType"));
1681                            }
1682                            children_type__ = Some(map_.next_value()?);
1683                        }
1684                    }
1685                }
1686                Ok(StructArrayData {
1687                    children_array: children_array__.unwrap_or_default(),
1688                    children_type: children_type__.unwrap_or_default(),
1689                })
1690            }
1691        }
1692        deserializer.deserialize_struct("data.StructArrayData", FIELDS, GeneratedVisitor)
1693    }
1694}
1695impl serde::Serialize for Terminate {
1696    #[allow(deprecated)]
1697    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1698    where
1699        S: serde::Serializer,
1700    {
1701        use serde::ser::SerializeStruct;
1702        let len = 0;
1703        let struct_ser = serializer.serialize_struct("data.Terminate", len)?;
1704        struct_ser.end()
1705    }
1706}
1707impl<'de> serde::Deserialize<'de> for Terminate {
1708    #[allow(deprecated)]
1709    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1710    where
1711        D: serde::Deserializer<'de>,
1712    {
1713        const FIELDS: &[&str] = &[
1714        ];
1715
1716        #[allow(clippy::enum_variant_names)]
1717        enum GeneratedField {
1718        }
1719        impl<'de> serde::Deserialize<'de> for GeneratedField {
1720            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1721            where
1722                D: serde::Deserializer<'de>,
1723            {
1724                struct GeneratedVisitor;
1725
1726                impl serde::de::Visitor<'_> for GeneratedVisitor {
1727                    type Value = GeneratedField;
1728
1729                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1730                        write!(formatter, "expected one of: {:?}", &FIELDS)
1731                    }
1732
1733                    #[allow(unused_variables)]
1734                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1735                    where
1736                        E: serde::de::Error,
1737                    {
1738                            Err(serde::de::Error::unknown_field(value, FIELDS))
1739                    }
1740                }
1741                deserializer.deserialize_identifier(GeneratedVisitor)
1742            }
1743        }
1744        struct GeneratedVisitor;
1745        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1746            type Value = Terminate;
1747
1748            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1749                formatter.write_str("struct data.Terminate")
1750            }
1751
1752            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Terminate, V::Error>
1753                where
1754                    V: serde::de::MapAccess<'de>,
1755            {
1756                while map_.next_key::<GeneratedField>()?.is_some() {
1757                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1758                }
1759                Ok(Terminate {
1760                })
1761            }
1762        }
1763        deserializer.deserialize_struct("data.Terminate", FIELDS, GeneratedVisitor)
1764    }
1765}
risingwave_pb/data.serde.rs

risingwave_pb/
data.serde.rs
