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