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 let mut struct_ser = serializer.serialize_struct("data.ListArrayData", len)?;
1235 if !self.offsets.is_empty() {
1236 struct_ser.serialize_field("offsets", &self.offsets)?;
1237 }
1238 if let Some(v) = self.value.as_ref() {
1239 struct_ser.serialize_field("value", v)?;
1240 }
1241 if let Some(v) = self.value_type.as_ref() {
1242 struct_ser.serialize_field("valueType", v)?;
1243 }
1244 struct_ser.end()
1245 }
1246}
1247impl<'de> serde::Deserialize<'de> for ListArrayData {
1248 #[allow(deprecated)]
1249 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1250 where
1251 D: serde::Deserializer<'de>,
1252 {
1253 const FIELDS: &[&str] = &[
1254 "offsets",
1255 "value",
1256 "value_type",
1257 "valueType",
1258 ];
1259
1260 #[allow(clippy::enum_variant_names)]
1261 enum GeneratedField {
1262 Offsets,
1263 Value,
1264 ValueType,
1265 }
1266 impl<'de> serde::Deserialize<'de> for GeneratedField {
1267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1268 where
1269 D: serde::Deserializer<'de>,
1270 {
1271 struct GeneratedVisitor;
1272
1273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1274 type Value = GeneratedField;
1275
1276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1277 write!(formatter, "expected one of: {:?}", &FIELDS)
1278 }
1279
1280 #[allow(unused_variables)]
1281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1282 where
1283 E: serde::de::Error,
1284 {
1285 match value {
1286 "offsets" => Ok(GeneratedField::Offsets),
1287 "value" => Ok(GeneratedField::Value),
1288 "valueType" | "value_type" => Ok(GeneratedField::ValueType),
1289 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1290 }
1291 }
1292 }
1293 deserializer.deserialize_identifier(GeneratedVisitor)
1294 }
1295 }
1296 struct GeneratedVisitor;
1297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1298 type Value = ListArrayData;
1299
1300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1301 formatter.write_str("struct data.ListArrayData")
1302 }
1303
1304 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListArrayData, V::Error>
1305 where
1306 V: serde::de::MapAccess<'de>,
1307 {
1308 let mut offsets__ = None;
1309 let mut value__ = None;
1310 let mut value_type__ = None;
1311 while let Some(k) = map_.next_key()? {
1312 match k {
1313 GeneratedField::Offsets => {
1314 if offsets__.is_some() {
1315 return Err(serde::de::Error::duplicate_field("offsets"));
1316 }
1317 offsets__ =
1318 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1319 .into_iter().map(|x| x.0).collect())
1320 ;
1321 }
1322 GeneratedField::Value => {
1323 if value__.is_some() {
1324 return Err(serde::de::Error::duplicate_field("value"));
1325 }
1326 value__ = map_.next_value()?;
1327 }
1328 GeneratedField::ValueType => {
1329 if value_type__.is_some() {
1330 return Err(serde::de::Error::duplicate_field("valueType"));
1331 }
1332 value_type__ = map_.next_value()?;
1333 }
1334 }
1335 }
1336 Ok(ListArrayData {
1337 offsets: offsets__.unwrap_or_default(),
1338 value: value__,
1339 value_type: value_type__,
1340 })
1341 }
1342 }
1343 deserializer.deserialize_struct("data.ListArrayData", FIELDS, GeneratedVisitor)
1344 }
1345}
1346impl serde::Serialize for Op {
1347 #[allow(deprecated)]
1348 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1349 where
1350 S: serde::Serializer,
1351 {
1352 let variant = match self {
1353 Self::Unspecified => "OP_UNSPECIFIED",
1354 Self::Insert => "INSERT",
1355 Self::Delete => "DELETE",
1356 Self::UpdateInsert => "UPDATE_INSERT",
1357 Self::UpdateDelete => "UPDATE_DELETE",
1358 };
1359 serializer.serialize_str(variant)
1360 }
1361}
1362impl<'de> serde::Deserialize<'de> for Op {
1363 #[allow(deprecated)]
1364 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1365 where
1366 D: serde::Deserializer<'de>,
1367 {
1368 const FIELDS: &[&str] = &[
1369 "OP_UNSPECIFIED",
1370 "INSERT",
1371 "DELETE",
1372 "UPDATE_INSERT",
1373 "UPDATE_DELETE",
1374 ];
1375
1376 struct GeneratedVisitor;
1377
1378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1379 type Value = Op;
1380
1381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1382 write!(formatter, "expected one of: {:?}", &FIELDS)
1383 }
1384
1385 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1386 where
1387 E: serde::de::Error,
1388 {
1389 i32::try_from(v)
1390 .ok()
1391 .and_then(|x| x.try_into().ok())
1392 .ok_or_else(|| {
1393 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1394 })
1395 }
1396
1397 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1398 where
1399 E: serde::de::Error,
1400 {
1401 i32::try_from(v)
1402 .ok()
1403 .and_then(|x| x.try_into().ok())
1404 .ok_or_else(|| {
1405 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1406 })
1407 }
1408
1409 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1410 where
1411 E: serde::de::Error,
1412 {
1413 match value {
1414 "OP_UNSPECIFIED" => Ok(Op::Unspecified),
1415 "INSERT" => Ok(Op::Insert),
1416 "DELETE" => Ok(Op::Delete),
1417 "UPDATE_INSERT" => Ok(Op::UpdateInsert),
1418 "UPDATE_DELETE" => Ok(Op::UpdateDelete),
1419 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1420 }
1421 }
1422 }
1423 deserializer.deserialize_any(GeneratedVisitor)
1424 }
1425}
1426impl serde::Serialize for StreamChunk {
1427 #[allow(deprecated)]
1428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1429 where
1430 S: serde::Serializer,
1431 {
1432 use serde::ser::SerializeStruct;
1433 let mut len = 0;
1434 if self.cardinality != 0 {
1435 len += 1;
1436 }
1437 if !self.ops.is_empty() {
1438 len += 1;
1439 }
1440 if !self.columns.is_empty() {
1441 len += 1;
1442 }
1443 let mut struct_ser = serializer.serialize_struct("data.StreamChunk", len)?;
1444 if self.cardinality != 0 {
1445 struct_ser.serialize_field("cardinality", &self.cardinality)?;
1446 }
1447 if !self.ops.is_empty() {
1448 let v = self.ops.iter().cloned().map(|v| {
1449 Op::try_from(v)
1450 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v)))
1451 }).collect::<std::result::Result<Vec<_>, _>>()?;
1452 struct_ser.serialize_field("ops", &v)?;
1453 }
1454 if !self.columns.is_empty() {
1455 struct_ser.serialize_field("columns", &self.columns)?;
1456 }
1457 struct_ser.end()
1458 }
1459}
1460impl<'de> serde::Deserialize<'de> for StreamChunk {
1461 #[allow(deprecated)]
1462 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1463 where
1464 D: serde::Deserializer<'de>,
1465 {
1466 const FIELDS: &[&str] = &[
1467 "cardinality",
1468 "ops",
1469 "columns",
1470 ];
1471
1472 #[allow(clippy::enum_variant_names)]
1473 enum GeneratedField {
1474 Cardinality,
1475 Ops,
1476 Columns,
1477 }
1478 impl<'de> serde::Deserialize<'de> for GeneratedField {
1479 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1480 where
1481 D: serde::Deserializer<'de>,
1482 {
1483 struct GeneratedVisitor;
1484
1485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1486 type Value = GeneratedField;
1487
1488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1489 write!(formatter, "expected one of: {:?}", &FIELDS)
1490 }
1491
1492 #[allow(unused_variables)]
1493 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1494 where
1495 E: serde::de::Error,
1496 {
1497 match value {
1498 "cardinality" => Ok(GeneratedField::Cardinality),
1499 "ops" => Ok(GeneratedField::Ops),
1500 "columns" => Ok(GeneratedField::Columns),
1501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1502 }
1503 }
1504 }
1505 deserializer.deserialize_identifier(GeneratedVisitor)
1506 }
1507 }
1508 struct GeneratedVisitor;
1509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1510 type Value = StreamChunk;
1511
1512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1513 formatter.write_str("struct data.StreamChunk")
1514 }
1515
1516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamChunk, V::Error>
1517 where
1518 V: serde::de::MapAccess<'de>,
1519 {
1520 let mut cardinality__ = None;
1521 let mut ops__ = None;
1522 let mut columns__ = None;
1523 while let Some(k) = map_.next_key()? {
1524 match k {
1525 GeneratedField::Cardinality => {
1526 if cardinality__.is_some() {
1527 return Err(serde::de::Error::duplicate_field("cardinality"));
1528 }
1529 cardinality__ =
1530 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1531 ;
1532 }
1533 GeneratedField::Ops => {
1534 if ops__.is_some() {
1535 return Err(serde::de::Error::duplicate_field("ops"));
1536 }
1537 ops__ = Some(map_.next_value::<Vec<Op>>()?.into_iter().map(|x| x as i32).collect());
1538 }
1539 GeneratedField::Columns => {
1540 if columns__.is_some() {
1541 return Err(serde::de::Error::duplicate_field("columns"));
1542 }
1543 columns__ = Some(map_.next_value()?);
1544 }
1545 }
1546 }
1547 Ok(StreamChunk {
1548 cardinality: cardinality__.unwrap_or_default(),
1549 ops: ops__.unwrap_or_default(),
1550 columns: columns__.unwrap_or_default(),
1551 })
1552 }
1553 }
1554 deserializer.deserialize_struct("data.StreamChunk", FIELDS, GeneratedVisitor)
1555 }
1556}
1557impl serde::Serialize for StructArrayData {
1558 #[allow(deprecated)]
1559 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1560 where
1561 S: serde::Serializer,
1562 {
1563 use serde::ser::SerializeStruct;
1564 let mut len = 0;
1565 if !self.children_array.is_empty() {
1566 len += 1;
1567 }
1568 if !self.children_type.is_empty() {
1569 len += 1;
1570 }
1571 let mut struct_ser = serializer.serialize_struct("data.StructArrayData", len)?;
1572 if !self.children_array.is_empty() {
1573 struct_ser.serialize_field("childrenArray", &self.children_array)?;
1574 }
1575 if !self.children_type.is_empty() {
1576 struct_ser.serialize_field("childrenType", &self.children_type)?;
1577 }
1578 struct_ser.end()
1579 }
1580}
1581impl<'de> serde::Deserialize<'de> for StructArrayData {
1582 #[allow(deprecated)]
1583 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1584 where
1585 D: serde::Deserializer<'de>,
1586 {
1587 const FIELDS: &[&str] = &[
1588 "children_array",
1589 "childrenArray",
1590 "children_type",
1591 "childrenType",
1592 ];
1593
1594 #[allow(clippy::enum_variant_names)]
1595 enum GeneratedField {
1596 ChildrenArray,
1597 ChildrenType,
1598 }
1599 impl<'de> serde::Deserialize<'de> for GeneratedField {
1600 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1601 where
1602 D: serde::Deserializer<'de>,
1603 {
1604 struct GeneratedVisitor;
1605
1606 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1607 type Value = GeneratedField;
1608
1609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1610 write!(formatter, "expected one of: {:?}", &FIELDS)
1611 }
1612
1613 #[allow(unused_variables)]
1614 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1615 where
1616 E: serde::de::Error,
1617 {
1618 match value {
1619 "childrenArray" | "children_array" => Ok(GeneratedField::ChildrenArray),
1620 "childrenType" | "children_type" => Ok(GeneratedField::ChildrenType),
1621 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1622 }
1623 }
1624 }
1625 deserializer.deserialize_identifier(GeneratedVisitor)
1626 }
1627 }
1628 struct GeneratedVisitor;
1629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1630 type Value = StructArrayData;
1631
1632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1633 formatter.write_str("struct data.StructArrayData")
1634 }
1635
1636 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StructArrayData, V::Error>
1637 where
1638 V: serde::de::MapAccess<'de>,
1639 {
1640 let mut children_array__ = None;
1641 let mut children_type__ = None;
1642 while let Some(k) = map_.next_key()? {
1643 match k {
1644 GeneratedField::ChildrenArray => {
1645 if children_array__.is_some() {
1646 return Err(serde::de::Error::duplicate_field("childrenArray"));
1647 }
1648 children_array__ = Some(map_.next_value()?);
1649 }
1650 GeneratedField::ChildrenType => {
1651 if children_type__.is_some() {
1652 return Err(serde::de::Error::duplicate_field("childrenType"));
1653 }
1654 children_type__ = Some(map_.next_value()?);
1655 }
1656 }
1657 }
1658 Ok(StructArrayData {
1659 children_array: children_array__.unwrap_or_default(),
1660 children_type: children_type__.unwrap_or_default(),
1661 })
1662 }
1663 }
1664 deserializer.deserialize_struct("data.StructArrayData", FIELDS, GeneratedVisitor)
1665 }
1666}
1667impl serde::Serialize for Terminate {
1668 #[allow(deprecated)]
1669 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1670 where
1671 S: serde::Serializer,
1672 {
1673 use serde::ser::SerializeStruct;
1674 let len = 0;
1675 let struct_ser = serializer.serialize_struct("data.Terminate", len)?;
1676 struct_ser.end()
1677 }
1678}
1679impl<'de> serde::Deserialize<'de> for Terminate {
1680 #[allow(deprecated)]
1681 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1682 where
1683 D: serde::Deserializer<'de>,
1684 {
1685 const FIELDS: &[&str] = &[
1686 ];
1687
1688 #[allow(clippy::enum_variant_names)]
1689 enum GeneratedField {
1690 }
1691 impl<'de> serde::Deserialize<'de> for GeneratedField {
1692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1693 where
1694 D: serde::Deserializer<'de>,
1695 {
1696 struct GeneratedVisitor;
1697
1698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1699 type Value = GeneratedField;
1700
1701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1702 write!(formatter, "expected one of: {:?}", &FIELDS)
1703 }
1704
1705 #[allow(unused_variables)]
1706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1707 where
1708 E: serde::de::Error,
1709 {
1710 Err(serde::de::Error::unknown_field(value, FIELDS))
1711 }
1712 }
1713 deserializer.deserialize_identifier(GeneratedVisitor)
1714 }
1715 }
1716 struct GeneratedVisitor;
1717 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1718 type Value = Terminate;
1719
1720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1721 formatter.write_str("struct data.Terminate")
1722 }
1723
1724 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Terminate, V::Error>
1725 where
1726 V: serde::de::MapAccess<'de>,
1727 {
1728 while map_.next_key::<GeneratedField>()?.is_some() {
1729 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1730 }
1731 Ok(Terminate {
1732 })
1733 }
1734 }
1735 deserializer.deserialize_struct("data.Terminate", FIELDS, GeneratedVisitor)
1736 }
1737}