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