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.field_type.is_empty() {
428            len += 1;
429        }
430        if !self.field_names.is_empty() {
431            len += 1;
432        }
433        if !self.field_ids.is_empty() {
434            len += 1;
435        }
436        let mut struct_ser = serializer.serialize_struct("data.DataType", len)?;
437        if self.type_name != 0 {
438            let v = data_type::TypeName::try_from(self.type_name)
439                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.type_name)))?;
440            struct_ser.serialize_field("typeName", &v)?;
441        }
442        if self.precision != 0 {
443            struct_ser.serialize_field("precision", &self.precision)?;
444        }
445        if !self.field_type.is_empty() {
446            struct_ser.serialize_field("fieldType", &self.field_type)?;
447        }
448        if !self.field_names.is_empty() {
449            struct_ser.serialize_field("fieldNames", &self.field_names)?;
450        }
451        if !self.field_ids.is_empty() {
452            struct_ser.serialize_field("fieldIds", &self.field_ids)?;
453        }
454        struct_ser.end()
455    }
456}
457impl<'de> serde::Deserialize<'de> for DataType {
458    #[allow(deprecated)]
459    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
460    where
461        D: serde::Deserializer<'de>,
462    {
463        const FIELDS: &[&str] = &[
464            "type_name",
465            "typeName",
466            "precision",
467            "field_type",
468            "fieldType",
469            "field_names",
470            "fieldNames",
471            "field_ids",
472            "fieldIds",
473        ];
474
475        #[allow(clippy::enum_variant_names)]
476        enum GeneratedField {
477            TypeName,
478            Precision,
479            FieldType,
480            FieldNames,
481            FieldIds,
482        }
483        impl<'de> serde::Deserialize<'de> for GeneratedField {
484            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
485            where
486                D: serde::Deserializer<'de>,
487            {
488                struct GeneratedVisitor;
489
490                impl serde::de::Visitor<'_> for GeneratedVisitor {
491                    type Value = GeneratedField;
492
493                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
494                        write!(formatter, "expected one of: {:?}", &FIELDS)
495                    }
496
497                    #[allow(unused_variables)]
498                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
499                    where
500                        E: serde::de::Error,
501                    {
502                        match value {
503                            "typeName" | "type_name" => Ok(GeneratedField::TypeName),
504                            "precision" => Ok(GeneratedField::Precision),
505                            "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
506                            "fieldNames" | "field_names" => Ok(GeneratedField::FieldNames),
507                            "fieldIds" | "field_ids" => Ok(GeneratedField::FieldIds),
508                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
509                        }
510                    }
511                }
512                deserializer.deserialize_identifier(GeneratedVisitor)
513            }
514        }
515        struct GeneratedVisitor;
516        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
517            type Value = DataType;
518
519            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
520                formatter.write_str("struct data.DataType")
521            }
522
523            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DataType, V::Error>
524                where
525                    V: serde::de::MapAccess<'de>,
526            {
527                let mut type_name__ = None;
528                let mut precision__ = None;
529                let mut field_type__ = None;
530                let mut field_names__ = None;
531                let mut field_ids__ = None;
532                while let Some(k) = map_.next_key()? {
533                    match k {
534                        GeneratedField::TypeName => {
535                            if type_name__.is_some() {
536                                return Err(serde::de::Error::duplicate_field("typeName"));
537                            }
538                            type_name__ = Some(map_.next_value::<data_type::TypeName>()? as i32);
539                        }
540                        GeneratedField::Precision => {
541                            if precision__.is_some() {
542                                return Err(serde::de::Error::duplicate_field("precision"));
543                            }
544                            precision__ = 
545                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
546                            ;
547                        }
548                        GeneratedField::FieldType => {
549                            if field_type__.is_some() {
550                                return Err(serde::de::Error::duplicate_field("fieldType"));
551                            }
552                            field_type__ = Some(map_.next_value()?);
553                        }
554                        GeneratedField::FieldNames => {
555                            if field_names__.is_some() {
556                                return Err(serde::de::Error::duplicate_field("fieldNames"));
557                            }
558                            field_names__ = Some(map_.next_value()?);
559                        }
560                        GeneratedField::FieldIds => {
561                            if field_ids__.is_some() {
562                                return Err(serde::de::Error::duplicate_field("fieldIds"));
563                            }
564                            field_ids__ = 
565                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
566                                    .into_iter().map(|x| x.0).collect())
567                            ;
568                        }
569                    }
570                }
571                Ok(DataType {
572                    type_name: type_name__.unwrap_or_default(),
573                    precision: precision__.unwrap_or_default(),
574                    field_type: field_type__.unwrap_or_default(),
575                    field_names: field_names__.unwrap_or_default(),
576                    field_ids: field_ids__.unwrap_or_default(),
577                })
578            }
579        }
580        deserializer.deserialize_struct("data.DataType", FIELDS, GeneratedVisitor)
581    }
582}
583impl serde::Serialize for data_type::TypeName {
584    #[allow(deprecated)]
585    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
586    where
587        S: serde::Serializer,
588    {
589        let variant = match self {
590            Self::TypeUnspecified => "TYPE_UNSPECIFIED",
591            Self::Int16 => "INT16",
592            Self::Int32 => "INT32",
593            Self::Int64 => "INT64",
594            Self::Float => "FLOAT",
595            Self::Double => "DOUBLE",
596            Self::Boolean => "BOOLEAN",
597            Self::Varchar => "VARCHAR",
598            Self::Decimal => "DECIMAL",
599            Self::Time => "TIME",
600            Self::Timestamp => "TIMESTAMP",
601            Self::Interval => "INTERVAL",
602            Self::Date => "DATE",
603            Self::Timestamptz => "TIMESTAMPTZ",
604            Self::Struct => "STRUCT",
605            Self::List => "LIST",
606            Self::Bytea => "BYTEA",
607            Self::Jsonb => "JSONB",
608            Self::Serial => "SERIAL",
609            Self::Int256 => "INT256",
610            Self::Map => "MAP",
611            Self::Vector => "VECTOR",
612            Self::Variant => "VARIANT",
613        };
614        serializer.serialize_str(variant)
615    }
616}
617impl<'de> serde::Deserialize<'de> for data_type::TypeName {
618    #[allow(deprecated)]
619    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
620    where
621        D: serde::Deserializer<'de>,
622    {
623        const FIELDS: &[&str] = &[
624            "TYPE_UNSPECIFIED",
625            "INT16",
626            "INT32",
627            "INT64",
628            "FLOAT",
629            "DOUBLE",
630            "BOOLEAN",
631            "VARCHAR",
632            "DECIMAL",
633            "TIME",
634            "TIMESTAMP",
635            "INTERVAL",
636            "DATE",
637            "TIMESTAMPTZ",
638            "STRUCT",
639            "LIST",
640            "BYTEA",
641            "JSONB",
642            "SERIAL",
643            "INT256",
644            "MAP",
645            "VECTOR",
646            "VARIANT",
647        ];
648
649        struct GeneratedVisitor;
650
651        impl serde::de::Visitor<'_> for GeneratedVisitor {
652            type Value = data_type::TypeName;
653
654            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
655                write!(formatter, "expected one of: {:?}", &FIELDS)
656            }
657
658            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
659            where
660                E: serde::de::Error,
661            {
662                i32::try_from(v)
663                    .ok()
664                    .and_then(|x| x.try_into().ok())
665                    .ok_or_else(|| {
666                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
667                    })
668            }
669
670            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
671            where
672                E: serde::de::Error,
673            {
674                i32::try_from(v)
675                    .ok()
676                    .and_then(|x| x.try_into().ok())
677                    .ok_or_else(|| {
678                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
679                    })
680            }
681
682            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
683            where
684                E: serde::de::Error,
685            {
686                match value {
687                    "TYPE_UNSPECIFIED" => Ok(data_type::TypeName::TypeUnspecified),
688                    "INT16" => Ok(data_type::TypeName::Int16),
689                    "INT32" => Ok(data_type::TypeName::Int32),
690                    "INT64" => Ok(data_type::TypeName::Int64),
691                    "FLOAT" => Ok(data_type::TypeName::Float),
692                    "DOUBLE" => Ok(data_type::TypeName::Double),
693                    "BOOLEAN" => Ok(data_type::TypeName::Boolean),
694                    "VARCHAR" => Ok(data_type::TypeName::Varchar),
695                    "DECIMAL" => Ok(data_type::TypeName::Decimal),
696                    "TIME" => Ok(data_type::TypeName::Time),
697                    "TIMESTAMP" => Ok(data_type::TypeName::Timestamp),
698                    "INTERVAL" => Ok(data_type::TypeName::Interval),
699                    "DATE" => Ok(data_type::TypeName::Date),
700                    "TIMESTAMPTZ" => Ok(data_type::TypeName::Timestamptz),
701                    "STRUCT" => Ok(data_type::TypeName::Struct),
702                    "LIST" => Ok(data_type::TypeName::List),
703                    "BYTEA" => Ok(data_type::TypeName::Bytea),
704                    "JSONB" => Ok(data_type::TypeName::Jsonb),
705                    "SERIAL" => Ok(data_type::TypeName::Serial),
706                    "INT256" => Ok(data_type::TypeName::Int256),
707                    "MAP" => Ok(data_type::TypeName::Map),
708                    "VECTOR" => Ok(data_type::TypeName::Vector),
709                    "VARIANT" => Ok(data_type::TypeName::Variant),
710                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
711                }
712            }
713        }
714        deserializer.deserialize_any(GeneratedVisitor)
715    }
716}
717impl serde::Serialize for Datum {
718    #[allow(deprecated)]
719    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
720    where
721        S: serde::Serializer,
722    {
723        use serde::ser::SerializeStruct;
724        let mut len = 0;
725        if !self.body.is_empty() {
726            len += 1;
727        }
728        let mut struct_ser = serializer.serialize_struct("data.Datum", len)?;
729        if !self.body.is_empty() {
730            #[allow(clippy::needless_borrow)]
731            #[allow(clippy::needless_borrows_for_generic_args)]
732            struct_ser.serialize_field("body", pbjson::private::base64::encode(&self.body).as_str())?;
733        }
734        struct_ser.end()
735    }
736}
737impl<'de> serde::Deserialize<'de> for Datum {
738    #[allow(deprecated)]
739    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
740    where
741        D: serde::Deserializer<'de>,
742    {
743        const FIELDS: &[&str] = &[
744            "body",
745        ];
746
747        #[allow(clippy::enum_variant_names)]
748        enum GeneratedField {
749            Body,
750        }
751        impl<'de> serde::Deserialize<'de> for GeneratedField {
752            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
753            where
754                D: serde::Deserializer<'de>,
755            {
756                struct GeneratedVisitor;
757
758                impl serde::de::Visitor<'_> for GeneratedVisitor {
759                    type Value = GeneratedField;
760
761                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
762                        write!(formatter, "expected one of: {:?}", &FIELDS)
763                    }
764
765                    #[allow(unused_variables)]
766                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
767                    where
768                        E: serde::de::Error,
769                    {
770                        match value {
771                            "body" => Ok(GeneratedField::Body),
772                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
773                        }
774                    }
775                }
776                deserializer.deserialize_identifier(GeneratedVisitor)
777            }
778        }
779        struct GeneratedVisitor;
780        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
781            type Value = Datum;
782
783            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
784                formatter.write_str("struct data.Datum")
785            }
786
787            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Datum, V::Error>
788                where
789                    V: serde::de::MapAccess<'de>,
790            {
791                let mut body__ = None;
792                while let Some(k) = map_.next_key()? {
793                    match k {
794                        GeneratedField::Body => {
795                            if body__.is_some() {
796                                return Err(serde::de::Error::duplicate_field("body"));
797                            }
798                            body__ = 
799                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
800                            ;
801                        }
802                    }
803                }
804                Ok(Datum {
805                    body: body__.unwrap_or_default(),
806                })
807            }
808        }
809        deserializer.deserialize_struct("data.Datum", FIELDS, GeneratedVisitor)
810    }
811}
812impl serde::Serialize for Epoch {
813    #[allow(deprecated)]
814    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
815    where
816        S: serde::Serializer,
817    {
818        use serde::ser::SerializeStruct;
819        let mut len = 0;
820        if self.curr != 0 {
821            len += 1;
822        }
823        if self.prev != 0 {
824            len += 1;
825        }
826        let mut struct_ser = serializer.serialize_struct("data.Epoch", len)?;
827        if self.curr != 0 {
828            #[allow(clippy::needless_borrow)]
829            #[allow(clippy::needless_borrows_for_generic_args)]
830            struct_ser.serialize_field("curr", ToString::to_string(&self.curr).as_str())?;
831        }
832        if self.prev != 0 {
833            #[allow(clippy::needless_borrow)]
834            #[allow(clippy::needless_borrows_for_generic_args)]
835            struct_ser.serialize_field("prev", ToString::to_string(&self.prev).as_str())?;
836        }
837        struct_ser.end()
838    }
839}
840impl<'de> serde::Deserialize<'de> for Epoch {
841    #[allow(deprecated)]
842    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
843    where
844        D: serde::Deserializer<'de>,
845    {
846        const FIELDS: &[&str] = &[
847            "curr",
848            "prev",
849        ];
850
851        #[allow(clippy::enum_variant_names)]
852        enum GeneratedField {
853            Curr,
854            Prev,
855        }
856        impl<'de> serde::Deserialize<'de> for GeneratedField {
857            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
858            where
859                D: serde::Deserializer<'de>,
860            {
861                struct GeneratedVisitor;
862
863                impl serde::de::Visitor<'_> for GeneratedVisitor {
864                    type Value = GeneratedField;
865
866                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
867                        write!(formatter, "expected one of: {:?}", &FIELDS)
868                    }
869
870                    #[allow(unused_variables)]
871                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
872                    where
873                        E: serde::de::Error,
874                    {
875                        match value {
876                            "curr" => Ok(GeneratedField::Curr),
877                            "prev" => Ok(GeneratedField::Prev),
878                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
879                        }
880                    }
881                }
882                deserializer.deserialize_identifier(GeneratedVisitor)
883            }
884        }
885        struct GeneratedVisitor;
886        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
887            type Value = Epoch;
888
889            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
890                formatter.write_str("struct data.Epoch")
891            }
892
893            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Epoch, V::Error>
894                where
895                    V: serde::de::MapAccess<'de>,
896            {
897                let mut curr__ = None;
898                let mut prev__ = None;
899                while let Some(k) = map_.next_key()? {
900                    match k {
901                        GeneratedField::Curr => {
902                            if curr__.is_some() {
903                                return Err(serde::de::Error::duplicate_field("curr"));
904                            }
905                            curr__ = 
906                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
907                            ;
908                        }
909                        GeneratedField::Prev => {
910                            if prev__.is_some() {
911                                return Err(serde::de::Error::duplicate_field("prev"));
912                            }
913                            prev__ = 
914                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
915                            ;
916                        }
917                    }
918                }
919                Ok(Epoch {
920                    curr: curr__.unwrap_or_default(),
921                    prev: prev__.unwrap_or_default(),
922                })
923            }
924        }
925        deserializer.deserialize_struct("data.Epoch", FIELDS, GeneratedVisitor)
926    }
927}
928impl serde::Serialize for Interval {
929    #[allow(deprecated)]
930    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
931    where
932        S: serde::Serializer,
933    {
934        use serde::ser::SerializeStruct;
935        let mut len = 0;
936        if self.months != 0 {
937            len += 1;
938        }
939        if self.days != 0 {
940            len += 1;
941        }
942        if self.usecs != 0 {
943            len += 1;
944        }
945        let mut struct_ser = serializer.serialize_struct("data.Interval", len)?;
946        if self.months != 0 {
947            struct_ser.serialize_field("months", &self.months)?;
948        }
949        if self.days != 0 {
950            struct_ser.serialize_field("days", &self.days)?;
951        }
952        if self.usecs != 0 {
953            #[allow(clippy::needless_borrow)]
954            #[allow(clippy::needless_borrows_for_generic_args)]
955            struct_ser.serialize_field("usecs", ToString::to_string(&self.usecs).as_str())?;
956        }
957        struct_ser.end()
958    }
959}
960impl<'de> serde::Deserialize<'de> for Interval {
961    #[allow(deprecated)]
962    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
963    where
964        D: serde::Deserializer<'de>,
965    {
966        const FIELDS: &[&str] = &[
967            "months",
968            "days",
969            "usecs",
970        ];
971
972        #[allow(clippy::enum_variant_names)]
973        enum GeneratedField {
974            Months,
975            Days,
976            Usecs,
977        }
978        impl<'de> serde::Deserialize<'de> for GeneratedField {
979            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
980            where
981                D: serde::Deserializer<'de>,
982            {
983                struct GeneratedVisitor;
984
985                impl serde::de::Visitor<'_> for GeneratedVisitor {
986                    type Value = GeneratedField;
987
988                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
989                        write!(formatter, "expected one of: {:?}", &FIELDS)
990                    }
991
992                    #[allow(unused_variables)]
993                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
994                    where
995                        E: serde::de::Error,
996                    {
997                        match value {
998                            "months" => Ok(GeneratedField::Months),
999                            "days" => Ok(GeneratedField::Days),
1000                            "usecs" => Ok(GeneratedField::Usecs),
1001                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1002                        }
1003                    }
1004                }
1005                deserializer.deserialize_identifier(GeneratedVisitor)
1006            }
1007        }
1008        struct GeneratedVisitor;
1009        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1010            type Value = Interval;
1011
1012            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1013                formatter.write_str("struct data.Interval")
1014            }
1015
1016            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Interval, V::Error>
1017                where
1018                    V: serde::de::MapAccess<'de>,
1019            {
1020                let mut months__ = None;
1021                let mut days__ = None;
1022                let mut usecs__ = None;
1023                while let Some(k) = map_.next_key()? {
1024                    match k {
1025                        GeneratedField::Months => {
1026                            if months__.is_some() {
1027                                return Err(serde::de::Error::duplicate_field("months"));
1028                            }
1029                            months__ = 
1030                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1031                            ;
1032                        }
1033                        GeneratedField::Days => {
1034                            if days__.is_some() {
1035                                return Err(serde::de::Error::duplicate_field("days"));
1036                            }
1037                            days__ = 
1038                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1039                            ;
1040                        }
1041                        GeneratedField::Usecs => {
1042                            if usecs__.is_some() {
1043                                return Err(serde::de::Error::duplicate_field("usecs"));
1044                            }
1045                            usecs__ = 
1046                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1047                            ;
1048                        }
1049                    }
1050                }
1051                Ok(Interval {
1052                    months: months__.unwrap_or_default(),
1053                    days: days__.unwrap_or_default(),
1054                    usecs: usecs__.unwrap_or_default(),
1055                })
1056            }
1057        }
1058        deserializer.deserialize_struct("data.Interval", FIELDS, GeneratedVisitor)
1059    }
1060}
1061impl serde::Serialize for ListArrayData {
1062    #[allow(deprecated)]
1063    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1064    where
1065        S: serde::Serializer,
1066    {
1067        use serde::ser::SerializeStruct;
1068        let mut len = 0;
1069        if !self.offsets.is_empty() {
1070            len += 1;
1071        }
1072        if self.value.is_some() {
1073            len += 1;
1074        }
1075        if self.value_type.is_some() {
1076            len += 1;
1077        }
1078        if self.elem_size.is_some() {
1079            len += 1;
1080        }
1081        let mut struct_ser = serializer.serialize_struct("data.ListArrayData", len)?;
1082        if !self.offsets.is_empty() {
1083            struct_ser.serialize_field("offsets", &self.offsets)?;
1084        }
1085        if let Some(v) = self.value.as_ref() {
1086            struct_ser.serialize_field("value", v)?;
1087        }
1088        if let Some(v) = self.value_type.as_ref() {
1089            struct_ser.serialize_field("valueType", v)?;
1090        }
1091        if let Some(v) = self.elem_size.as_ref() {
1092            struct_ser.serialize_field("elemSize", v)?;
1093        }
1094        struct_ser.end()
1095    }
1096}
1097impl<'de> serde::Deserialize<'de> for ListArrayData {
1098    #[allow(deprecated)]
1099    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1100    where
1101        D: serde::Deserializer<'de>,
1102    {
1103        const FIELDS: &[&str] = &[
1104            "offsets",
1105            "value",
1106            "value_type",
1107            "valueType",
1108            "elem_size",
1109            "elemSize",
1110        ];
1111
1112        #[allow(clippy::enum_variant_names)]
1113        enum GeneratedField {
1114            Offsets,
1115            Value,
1116            ValueType,
1117            ElemSize,
1118        }
1119        impl<'de> serde::Deserialize<'de> for GeneratedField {
1120            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1121            where
1122                D: serde::Deserializer<'de>,
1123            {
1124                struct GeneratedVisitor;
1125
1126                impl serde::de::Visitor<'_> for GeneratedVisitor {
1127                    type Value = GeneratedField;
1128
1129                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1130                        write!(formatter, "expected one of: {:?}", &FIELDS)
1131                    }
1132
1133                    #[allow(unused_variables)]
1134                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1135                    where
1136                        E: serde::de::Error,
1137                    {
1138                        match value {
1139                            "offsets" => Ok(GeneratedField::Offsets),
1140                            "value" => Ok(GeneratedField::Value),
1141                            "valueType" | "value_type" => Ok(GeneratedField::ValueType),
1142                            "elemSize" | "elem_size" => Ok(GeneratedField::ElemSize),
1143                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1144                        }
1145                    }
1146                }
1147                deserializer.deserialize_identifier(GeneratedVisitor)
1148            }
1149        }
1150        struct GeneratedVisitor;
1151        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1152            type Value = ListArrayData;
1153
1154            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1155                formatter.write_str("struct data.ListArrayData")
1156            }
1157
1158            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListArrayData, V::Error>
1159                where
1160                    V: serde::de::MapAccess<'de>,
1161            {
1162                let mut offsets__ = None;
1163                let mut value__ = None;
1164                let mut value_type__ = None;
1165                let mut elem_size__ = None;
1166                while let Some(k) = map_.next_key()? {
1167                    match k {
1168                        GeneratedField::Offsets => {
1169                            if offsets__.is_some() {
1170                                return Err(serde::de::Error::duplicate_field("offsets"));
1171                            }
1172                            offsets__ = 
1173                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1174                                    .into_iter().map(|x| x.0).collect())
1175                            ;
1176                        }
1177                        GeneratedField::Value => {
1178                            if value__.is_some() {
1179                                return Err(serde::de::Error::duplicate_field("value"));
1180                            }
1181                            value__ = map_.next_value()?;
1182                        }
1183                        GeneratedField::ValueType => {
1184                            if value_type__.is_some() {
1185                                return Err(serde::de::Error::duplicate_field("valueType"));
1186                            }
1187                            value_type__ = map_.next_value()?;
1188                        }
1189                        GeneratedField::ElemSize => {
1190                            if elem_size__.is_some() {
1191                                return Err(serde::de::Error::duplicate_field("elemSize"));
1192                            }
1193                            elem_size__ = 
1194                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1195                            ;
1196                        }
1197                    }
1198                }
1199                Ok(ListArrayData {
1200                    offsets: offsets__.unwrap_or_default(),
1201                    value: value__,
1202                    value_type: value_type__,
1203                    elem_size: elem_size__,
1204                })
1205            }
1206        }
1207        deserializer.deserialize_struct("data.ListArrayData", FIELDS, GeneratedVisitor)
1208    }
1209}
1210impl serde::Serialize for Op {
1211    #[allow(deprecated)]
1212    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1213    where
1214        S: serde::Serializer,
1215    {
1216        let variant = match self {
1217            Self::Unspecified => "OP_UNSPECIFIED",
1218            Self::Insert => "INSERT",
1219            Self::Delete => "DELETE",
1220            Self::UpdateInsert => "UPDATE_INSERT",
1221            Self::UpdateDelete => "UPDATE_DELETE",
1222        };
1223        serializer.serialize_str(variant)
1224    }
1225}
1226impl<'de> serde::Deserialize<'de> for Op {
1227    #[allow(deprecated)]
1228    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1229    where
1230        D: serde::Deserializer<'de>,
1231    {
1232        const FIELDS: &[&str] = &[
1233            "OP_UNSPECIFIED",
1234            "INSERT",
1235            "DELETE",
1236            "UPDATE_INSERT",
1237            "UPDATE_DELETE",
1238        ];
1239
1240        struct GeneratedVisitor;
1241
1242        impl serde::de::Visitor<'_> for GeneratedVisitor {
1243            type Value = Op;
1244
1245            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1246                write!(formatter, "expected one of: {:?}", &FIELDS)
1247            }
1248
1249            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1250            where
1251                E: serde::de::Error,
1252            {
1253                i32::try_from(v)
1254                    .ok()
1255                    .and_then(|x| x.try_into().ok())
1256                    .ok_or_else(|| {
1257                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1258                    })
1259            }
1260
1261            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1262            where
1263                E: serde::de::Error,
1264            {
1265                i32::try_from(v)
1266                    .ok()
1267                    .and_then(|x| x.try_into().ok())
1268                    .ok_or_else(|| {
1269                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1270                    })
1271            }
1272
1273            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1274            where
1275                E: serde::de::Error,
1276            {
1277                match value {
1278                    "OP_UNSPECIFIED" => Ok(Op::Unspecified),
1279                    "INSERT" => Ok(Op::Insert),
1280                    "DELETE" => Ok(Op::Delete),
1281                    "UPDATE_INSERT" => Ok(Op::UpdateInsert),
1282                    "UPDATE_DELETE" => Ok(Op::UpdateDelete),
1283                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1284                }
1285            }
1286        }
1287        deserializer.deserialize_any(GeneratedVisitor)
1288    }
1289}
1290impl serde::Serialize for StreamChunk {
1291    #[allow(deprecated)]
1292    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1293    where
1294        S: serde::Serializer,
1295    {
1296        use serde::ser::SerializeStruct;
1297        let mut len = 0;
1298        if self.cardinality != 0 {
1299            len += 1;
1300        }
1301        if !self.ops.is_empty() {
1302            len += 1;
1303        }
1304        if !self.columns.is_empty() {
1305            len += 1;
1306        }
1307        let mut struct_ser = serializer.serialize_struct("data.StreamChunk", len)?;
1308        if self.cardinality != 0 {
1309            struct_ser.serialize_field("cardinality", &self.cardinality)?;
1310        }
1311        if !self.ops.is_empty() {
1312            let v = self.ops.iter().cloned().map(|v| {
1313                Op::try_from(v)
1314                    .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v)))
1315                }).collect::<std::result::Result<Vec<_>, _>>()?;
1316            struct_ser.serialize_field("ops", &v)?;
1317        }
1318        if !self.columns.is_empty() {
1319            struct_ser.serialize_field("columns", &self.columns)?;
1320        }
1321        struct_ser.end()
1322    }
1323}
1324impl<'de> serde::Deserialize<'de> for StreamChunk {
1325    #[allow(deprecated)]
1326    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1327    where
1328        D: serde::Deserializer<'de>,
1329    {
1330        const FIELDS: &[&str] = &[
1331            "cardinality",
1332            "ops",
1333            "columns",
1334        ];
1335
1336        #[allow(clippy::enum_variant_names)]
1337        enum GeneratedField {
1338            Cardinality,
1339            Ops,
1340            Columns,
1341        }
1342        impl<'de> serde::Deserialize<'de> for GeneratedField {
1343            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1344            where
1345                D: serde::Deserializer<'de>,
1346            {
1347                struct GeneratedVisitor;
1348
1349                impl serde::de::Visitor<'_> for GeneratedVisitor {
1350                    type Value = GeneratedField;
1351
1352                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1353                        write!(formatter, "expected one of: {:?}", &FIELDS)
1354                    }
1355
1356                    #[allow(unused_variables)]
1357                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1358                    where
1359                        E: serde::de::Error,
1360                    {
1361                        match value {
1362                            "cardinality" => Ok(GeneratedField::Cardinality),
1363                            "ops" => Ok(GeneratedField::Ops),
1364                            "columns" => Ok(GeneratedField::Columns),
1365                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1366                        }
1367                    }
1368                }
1369                deserializer.deserialize_identifier(GeneratedVisitor)
1370            }
1371        }
1372        struct GeneratedVisitor;
1373        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1374            type Value = StreamChunk;
1375
1376            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1377                formatter.write_str("struct data.StreamChunk")
1378            }
1379
1380            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamChunk, V::Error>
1381                where
1382                    V: serde::de::MapAccess<'de>,
1383            {
1384                let mut cardinality__ = None;
1385                let mut ops__ = None;
1386                let mut columns__ = None;
1387                while let Some(k) = map_.next_key()? {
1388                    match k {
1389                        GeneratedField::Cardinality => {
1390                            if cardinality__.is_some() {
1391                                return Err(serde::de::Error::duplicate_field("cardinality"));
1392                            }
1393                            cardinality__ = 
1394                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1395                            ;
1396                        }
1397                        GeneratedField::Ops => {
1398                            if ops__.is_some() {
1399                                return Err(serde::de::Error::duplicate_field("ops"));
1400                            }
1401                            ops__ = Some(map_.next_value::<Vec<Op>>()?.into_iter().map(|x| x as i32).collect());
1402                        }
1403                        GeneratedField::Columns => {
1404                            if columns__.is_some() {
1405                                return Err(serde::de::Error::duplicate_field("columns"));
1406                            }
1407                            columns__ = Some(map_.next_value()?);
1408                        }
1409                    }
1410                }
1411                Ok(StreamChunk {
1412                    cardinality: cardinality__.unwrap_or_default(),
1413                    ops: ops__.unwrap_or_default(),
1414                    columns: columns__.unwrap_or_default(),
1415                })
1416            }
1417        }
1418        deserializer.deserialize_struct("data.StreamChunk", FIELDS, GeneratedVisitor)
1419    }
1420}
1421impl serde::Serialize for StructArrayData {
1422    #[allow(deprecated)]
1423    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1424    where
1425        S: serde::Serializer,
1426    {
1427        use serde::ser::SerializeStruct;
1428        let mut len = 0;
1429        if !self.children_array.is_empty() {
1430            len += 1;
1431        }
1432        if !self.children_type.is_empty() {
1433            len += 1;
1434        }
1435        let mut struct_ser = serializer.serialize_struct("data.StructArrayData", len)?;
1436        if !self.children_array.is_empty() {
1437            struct_ser.serialize_field("childrenArray", &self.children_array)?;
1438        }
1439        if !self.children_type.is_empty() {
1440            struct_ser.serialize_field("childrenType", &self.children_type)?;
1441        }
1442        struct_ser.end()
1443    }
1444}
1445impl<'de> serde::Deserialize<'de> for StructArrayData {
1446    #[allow(deprecated)]
1447    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1448    where
1449        D: serde::Deserializer<'de>,
1450    {
1451        const FIELDS: &[&str] = &[
1452            "children_array",
1453            "childrenArray",
1454            "children_type",
1455            "childrenType",
1456        ];
1457
1458        #[allow(clippy::enum_variant_names)]
1459        enum GeneratedField {
1460            ChildrenArray,
1461            ChildrenType,
1462        }
1463        impl<'de> serde::Deserialize<'de> for GeneratedField {
1464            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1465            where
1466                D: serde::Deserializer<'de>,
1467            {
1468                struct GeneratedVisitor;
1469
1470                impl serde::de::Visitor<'_> for GeneratedVisitor {
1471                    type Value = GeneratedField;
1472
1473                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1474                        write!(formatter, "expected one of: {:?}", &FIELDS)
1475                    }
1476
1477                    #[allow(unused_variables)]
1478                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1479                    where
1480                        E: serde::de::Error,
1481                    {
1482                        match value {
1483                            "childrenArray" | "children_array" => Ok(GeneratedField::ChildrenArray),
1484                            "childrenType" | "children_type" => Ok(GeneratedField::ChildrenType),
1485                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1486                        }
1487                    }
1488                }
1489                deserializer.deserialize_identifier(GeneratedVisitor)
1490            }
1491        }
1492        struct GeneratedVisitor;
1493        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1494            type Value = StructArrayData;
1495
1496            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1497                formatter.write_str("struct data.StructArrayData")
1498            }
1499
1500            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StructArrayData, V::Error>
1501                where
1502                    V: serde::de::MapAccess<'de>,
1503            {
1504                let mut children_array__ = None;
1505                let mut children_type__ = None;
1506                while let Some(k) = map_.next_key()? {
1507                    match k {
1508                        GeneratedField::ChildrenArray => {
1509                            if children_array__.is_some() {
1510                                return Err(serde::de::Error::duplicate_field("childrenArray"));
1511                            }
1512                            children_array__ = Some(map_.next_value()?);
1513                        }
1514                        GeneratedField::ChildrenType => {
1515                            if children_type__.is_some() {
1516                                return Err(serde::de::Error::duplicate_field("childrenType"));
1517                            }
1518                            children_type__ = Some(map_.next_value()?);
1519                        }
1520                    }
1521                }
1522                Ok(StructArrayData {
1523                    children_array: children_array__.unwrap_or_default(),
1524                    children_type: children_type__.unwrap_or_default(),
1525                })
1526            }
1527        }
1528        deserializer.deserialize_struct("data.StructArrayData", FIELDS, GeneratedVisitor)
1529    }
1530}
1531impl serde::Serialize for Terminate {
1532    #[allow(deprecated)]
1533    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1534    where
1535        S: serde::Serializer,
1536    {
1537        use serde::ser::SerializeStruct;
1538        let len = 0;
1539        let struct_ser = serializer.serialize_struct("data.Terminate", len)?;
1540        struct_ser.end()
1541    }
1542}
1543impl<'de> serde::Deserialize<'de> for Terminate {
1544    #[allow(deprecated)]
1545    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1546    where
1547        D: serde::Deserializer<'de>,
1548    {
1549        const FIELDS: &[&str] = &[
1550        ];
1551
1552        #[allow(clippy::enum_variant_names)]
1553        enum GeneratedField {
1554        }
1555        impl<'de> serde::Deserialize<'de> for GeneratedField {
1556            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1557            where
1558                D: serde::Deserializer<'de>,
1559            {
1560                struct GeneratedVisitor;
1561
1562                impl serde::de::Visitor<'_> for GeneratedVisitor {
1563                    type Value = GeneratedField;
1564
1565                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1566                        write!(formatter, "expected one of: {:?}", &FIELDS)
1567                    }
1568
1569                    #[allow(unused_variables)]
1570                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1571                    where
1572                        E: serde::de::Error,
1573                    {
1574                            Err(serde::de::Error::unknown_field(value, FIELDS))
1575                    }
1576                }
1577                deserializer.deserialize_identifier(GeneratedVisitor)
1578            }
1579        }
1580        struct GeneratedVisitor;
1581        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1582            type Value = Terminate;
1583
1584            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1585                formatter.write_str("struct data.Terminate")
1586            }
1587
1588            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Terminate, V::Error>
1589                where
1590                    V: serde::de::MapAccess<'de>,
1591            {
1592                while map_.next_key::<GeneratedField>()?.is_some() {
1593                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1594                }
1595                Ok(Terminate {
1596                })
1597            }
1598        }
1599        deserializer.deserialize_struct("data.Terminate", FIELDS, GeneratedVisitor)
1600    }
1601}
risingwave_pb/data.serde.rs

risingwave_pb/
data.serde.rs
