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