1#[derive(Clone, PartialEq, Default)]
5#[derive(::serde::Serialize, ::serde::Deserialize)]
6#[serde(default)]
7pub struct Row {
8 #[serde(
10 rename = "cells",
11 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
12 deserialize_with = "::buffa::json_helpers::null_as_default"
13 )]
14 pub cells: ::buffa::alloc::vec::Vec<Cell>,
15 #[serde(skip)]
16 #[doc(hidden)]
17 pub __buffa_unknown_fields: ::buffa::UnknownFields,
18}
19impl ::core::fmt::Debug for Row {
20 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
21 f.debug_struct("Row").field("cells", &self.cells).finish()
22 }
23}
24impl Row {
25 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Row";
30}
31impl ::buffa::DefaultInstance for Row {
32 fn default_instance() -> &'static Self {
33 static VALUE: ::buffa::__private::OnceBox<Row> = ::buffa::__private::OnceBox::new();
34 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
35 }
36}
37impl ::buffa::MessageName for Row {
38 const PACKAGE: &'static str = "sql.v1";
39 const NAME: &'static str = "Row";
40 const FULL_NAME: &'static str = "sql.v1.Row";
41 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Row";
42}
43impl ::buffa::Message for Row {
44 #[allow(clippy::let_and_return)]
50 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
51 #[allow(unused_imports)]
52 use ::buffa::Enumeration as _;
53 let mut size = 0u32;
54 for v in &self.cells {
55 let __slot = __cache.reserve();
56 let inner_size = v.compute_size(__cache);
57 __cache.set(__slot, inner_size);
58 size
59 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
60 + inner_size;
61 }
62 size += self.__buffa_unknown_fields.encoded_len() as u32;
63 size
64 }
65 fn write_to(
66 &self,
67 __cache: &mut ::buffa::SizeCache,
68 buf: &mut impl ::buffa::bytes::BufMut,
69 ) {
70 #[allow(unused_imports)]
71 use ::buffa::Enumeration as _;
72 for v in &self.cells {
73 ::buffa::encoding::Tag::new(
74 1u32,
75 ::buffa::encoding::WireType::LengthDelimited,
76 )
77 .encode(buf);
78 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
79 v.write_to(__cache, buf);
80 }
81 self.__buffa_unknown_fields.write_to(buf);
82 }
83 fn merge_field(
84 &mut self,
85 tag: ::buffa::encoding::Tag,
86 buf: &mut impl ::buffa::bytes::Buf,
87 depth: u32,
88 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
89 #[allow(unused_imports)]
90 use ::buffa::bytes::Buf as _;
91 #[allow(unused_imports)]
92 use ::buffa::Enumeration as _;
93 match tag.field_number() {
94 1u32 => {
95 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
96 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
97 field_number: 1u32,
98 expected: 2u8,
99 actual: tag.wire_type() as u8,
100 });
101 }
102 let mut elem = ::core::default::Default::default();
103 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
104 self.cells.push(elem);
105 }
106 _ => {
107 self.__buffa_unknown_fields
108 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
109 }
110 }
111 ::core::result::Result::Ok(())
112 }
113 fn clear(&mut self) {
114 self.cells.clear();
115 self.__buffa_unknown_fields.clear();
116 }
117}
118impl ::buffa::ExtensionSet for Row {
119 const PROTO_FQN: &'static str = "sql.v1.Row";
120 fn unknown_fields(&self) -> &::buffa::UnknownFields {
121 &self.__buffa_unknown_fields
122 }
123 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
124 &mut self.__buffa_unknown_fields
125 }
126}
127impl ::buffa::json_helpers::ProtoElemJson for Row {
128 fn serialize_proto_json<S: ::serde::Serializer>(
129 v: &Self,
130 s: S,
131 ) -> ::core::result::Result<S::Ok, S::Error> {
132 ::serde::Serialize::serialize(v, s)
133 }
134 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
135 d: D,
136 ) -> ::core::result::Result<Self, D::Error> {
137 <Self as ::serde::Deserialize>::deserialize(d)
138 }
139}
140#[doc(hidden)]
141pub const __ROW_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
142 type_url: "type.googleapis.com/sql.v1.Row",
143 to_json: ::buffa::type_registry::any_to_json::<Row>,
144 from_json: ::buffa::type_registry::any_from_json::<Row>,
145 is_wkt: false,
146};
147#[derive(Clone, PartialEq, Default)]
150#[derive(::serde::Serialize, ::serde::Deserialize)]
151#[serde(default)]
152pub struct Null {
153 #[serde(skip)]
154 #[doc(hidden)]
155 pub __buffa_unknown_fields: ::buffa::UnknownFields,
156}
157impl ::core::fmt::Debug for Null {
158 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
159 f.debug_struct("Null").finish()
160 }
161}
162impl Null {
163 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Null";
168}
169impl ::buffa::DefaultInstance for Null {
170 fn default_instance() -> &'static Self {
171 static VALUE: ::buffa::__private::OnceBox<Null> = ::buffa::__private::OnceBox::new();
172 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
173 }
174}
175impl ::buffa::MessageName for Null {
176 const PACKAGE: &'static str = "sql.v1";
177 const NAME: &'static str = "Null";
178 const FULL_NAME: &'static str = "sql.v1.Null";
179 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Null";
180}
181impl ::buffa::Message for Null {
182 #[allow(clippy::let_and_return)]
188 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
189 #[allow(unused_imports)]
190 use ::buffa::Enumeration as _;
191 let mut size = 0u32;
192 size += self.__buffa_unknown_fields.encoded_len() as u32;
193 size
194 }
195 fn write_to(
196 &self,
197 _cache: &mut ::buffa::SizeCache,
198 buf: &mut impl ::buffa::bytes::BufMut,
199 ) {
200 #[allow(unused_imports)]
201 use ::buffa::Enumeration as _;
202 self.__buffa_unknown_fields.write_to(buf);
203 }
204 fn merge_field(
205 &mut self,
206 tag: ::buffa::encoding::Tag,
207 buf: &mut impl ::buffa::bytes::Buf,
208 depth: u32,
209 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
210 #[allow(unused_imports)]
211 use ::buffa::bytes::Buf as _;
212 #[allow(unused_imports)]
213 use ::buffa::Enumeration as _;
214 match tag.field_number() {
215 _ => {
216 self.__buffa_unknown_fields
217 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
218 }
219 }
220 ::core::result::Result::Ok(())
221 }
222 fn clear(&mut self) {
223 self.__buffa_unknown_fields.clear();
224 }
225}
226impl ::buffa::ExtensionSet for Null {
227 const PROTO_FQN: &'static str = "sql.v1.Null";
228 fn unknown_fields(&self) -> &::buffa::UnknownFields {
229 &self.__buffa_unknown_fields
230 }
231 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
232 &mut self.__buffa_unknown_fields
233 }
234}
235impl ::buffa::json_helpers::ProtoElemJson for Null {
236 fn serialize_proto_json<S: ::serde::Serializer>(
237 v: &Self,
238 s: S,
239 ) -> ::core::result::Result<S::Ok, S::Error> {
240 ::serde::Serialize::serialize(v, s)
241 }
242 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
243 d: D,
244 ) -> ::core::result::Result<Self, D::Error> {
245 <Self as ::serde::Deserialize>::deserialize(d)
246 }
247}
248#[doc(hidden)]
249pub const __NULL_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
250 type_url: "type.googleapis.com/sql.v1.Null",
251 to_json: ::buffa::type_registry::any_to_json::<Null>,
252 from_json: ::buffa::type_registry::any_from_json::<Null>,
253 is_wkt: false,
254};
255#[derive(Clone, PartialEq, Default)]
258#[derive(::serde::Serialize, ::serde::Deserialize)]
259#[serde(default)]
260pub struct ListValue {
261 #[serde(
263 rename = "elements",
264 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
265 deserialize_with = "::buffa::json_helpers::null_as_default"
266 )]
267 pub elements: ::buffa::alloc::vec::Vec<Cell>,
268 #[serde(skip)]
269 #[doc(hidden)]
270 pub __buffa_unknown_fields: ::buffa::UnknownFields,
271}
272impl ::core::fmt::Debug for ListValue {
273 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
274 f.debug_struct("ListValue").field("elements", &self.elements).finish()
275 }
276}
277impl ListValue {
278 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.ListValue";
283}
284impl ::buffa::DefaultInstance for ListValue {
285 fn default_instance() -> &'static Self {
286 static VALUE: ::buffa::__private::OnceBox<ListValue> = ::buffa::__private::OnceBox::new();
287 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
288 }
289}
290impl ::buffa::MessageName for ListValue {
291 const PACKAGE: &'static str = "sql.v1";
292 const NAME: &'static str = "ListValue";
293 const FULL_NAME: &'static str = "sql.v1.ListValue";
294 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.ListValue";
295}
296impl ::buffa::Message for ListValue {
297 #[allow(clippy::let_and_return)]
303 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
304 #[allow(unused_imports)]
305 use ::buffa::Enumeration as _;
306 let mut size = 0u32;
307 for v in &self.elements {
308 let __slot = __cache.reserve();
309 let inner_size = v.compute_size(__cache);
310 __cache.set(__slot, inner_size);
311 size
312 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
313 + inner_size;
314 }
315 size += self.__buffa_unknown_fields.encoded_len() as u32;
316 size
317 }
318 fn write_to(
319 &self,
320 __cache: &mut ::buffa::SizeCache,
321 buf: &mut impl ::buffa::bytes::BufMut,
322 ) {
323 #[allow(unused_imports)]
324 use ::buffa::Enumeration as _;
325 for v in &self.elements {
326 ::buffa::encoding::Tag::new(
327 1u32,
328 ::buffa::encoding::WireType::LengthDelimited,
329 )
330 .encode(buf);
331 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
332 v.write_to(__cache, buf);
333 }
334 self.__buffa_unknown_fields.write_to(buf);
335 }
336 fn merge_field(
337 &mut self,
338 tag: ::buffa::encoding::Tag,
339 buf: &mut impl ::buffa::bytes::Buf,
340 depth: u32,
341 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
342 #[allow(unused_imports)]
343 use ::buffa::bytes::Buf as _;
344 #[allow(unused_imports)]
345 use ::buffa::Enumeration as _;
346 match tag.field_number() {
347 1u32 => {
348 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
349 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
350 field_number: 1u32,
351 expected: 2u8,
352 actual: tag.wire_type() as u8,
353 });
354 }
355 let mut elem = ::core::default::Default::default();
356 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
357 self.elements.push(elem);
358 }
359 _ => {
360 self.__buffa_unknown_fields
361 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
362 }
363 }
364 ::core::result::Result::Ok(())
365 }
366 fn clear(&mut self) {
367 self.elements.clear();
368 self.__buffa_unknown_fields.clear();
369 }
370}
371impl ::buffa::ExtensionSet for ListValue {
372 const PROTO_FQN: &'static str = "sql.v1.ListValue";
373 fn unknown_fields(&self) -> &::buffa::UnknownFields {
374 &self.__buffa_unknown_fields
375 }
376 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
377 &mut self.__buffa_unknown_fields
378 }
379}
380impl ::buffa::json_helpers::ProtoElemJson for ListValue {
381 fn serialize_proto_json<S: ::serde::Serializer>(
382 v: &Self,
383 s: S,
384 ) -> ::core::result::Result<S::Ok, S::Error> {
385 ::serde::Serialize::serialize(v, s)
386 }
387 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
388 d: D,
389 ) -> ::core::result::Result<Self, D::Error> {
390 <Self as ::serde::Deserialize>::deserialize(d)
391 }
392}
393#[doc(hidden)]
394pub const __LIST_VALUE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
395 type_url: "type.googleapis.com/sql.v1.ListValue",
396 to_json: ::buffa::type_registry::any_to_json::<ListValue>,
397 from_json: ::buffa::type_registry::any_from_json::<ListValue>,
398 is_wkt: false,
399};
400#[derive(Clone, PartialEq, Default)]
404#[derive(::serde::Serialize)]
405#[serde(default)]
406pub struct Cell {
407 #[serde(flatten)]
408 pub kind: ::core::option::Option<__buffa::oneof::cell::Kind>,
409 #[serde(skip)]
410 #[doc(hidden)]
411 pub __buffa_unknown_fields: ::buffa::UnknownFields,
412}
413impl ::core::fmt::Debug for Cell {
414 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
415 f.debug_struct("Cell").field("kind", &self.kind).finish()
416 }
417}
418impl Cell {
419 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Cell";
424}
425impl ::buffa::DefaultInstance for Cell {
426 fn default_instance() -> &'static Self {
427 static VALUE: ::buffa::__private::OnceBox<Cell> = ::buffa::__private::OnceBox::new();
428 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
429 }
430}
431impl ::buffa::MessageName for Cell {
432 const PACKAGE: &'static str = "sql.v1";
433 const NAME: &'static str = "Cell";
434 const FULL_NAME: &'static str = "sql.v1.Cell";
435 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Cell";
436}
437impl ::buffa::Message for Cell {
438 #[allow(clippy::let_and_return)]
444 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
445 #[allow(unused_imports)]
446 use ::buffa::Enumeration as _;
447 let mut size = 0u32;
448 if let ::core::option::Option::Some(ref v) = self.kind {
449 match v {
450 __buffa::oneof::cell::Kind::NullValue(x) => {
451 let __slot = __cache.reserve();
452 let inner = x.compute_size(__cache);
453 __cache.set(__slot, inner);
454 size
455 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
456 + inner;
457 }
458 __buffa::oneof::cell::Kind::Int64Value(v) => {
459 size += 1u32 + ::buffa::types::int64_encoded_len(*v) as u32;
460 }
461 __buffa::oneof::cell::Kind::Uint64Value(v) => {
462 size += 1u32 + ::buffa::types::uint64_encoded_len(*v) as u32;
463 }
464 __buffa::oneof::cell::Kind::Float64Value(_x) => {
465 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
466 }
467 __buffa::oneof::cell::Kind::BooleanValue(_x) => {
468 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
469 }
470 __buffa::oneof::cell::Kind::Utf8Value(x) => {
471 size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
472 }
473 __buffa::oneof::cell::Kind::FixedSizeBinaryValue(x) => {
474 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
475 }
476 __buffa::oneof::cell::Kind::Date32Value(v) => {
477 size += 1u32 + ::buffa::types::int32_encoded_len(*v) as u32;
478 }
479 __buffa::oneof::cell::Kind::Date64Value(v) => {
480 size += 1u32 + ::buffa::types::int64_encoded_len(*v) as u32;
481 }
482 __buffa::oneof::cell::Kind::TimestampValue(v) => {
483 size += 1u32 + ::buffa::types::int64_encoded_len(*v) as u32;
484 }
485 __buffa::oneof::cell::Kind::Decimal128Value(x) => {
486 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
487 }
488 __buffa::oneof::cell::Kind::Decimal256Value(x) => {
489 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
490 }
491 __buffa::oneof::cell::Kind::ListValue(x) => {
492 let __slot = __cache.reserve();
493 let inner = x.compute_size(__cache);
494 __cache.set(__slot, inner);
495 size
496 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
497 + inner;
498 }
499 __buffa::oneof::cell::Kind::BinaryValue(x) => {
500 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
501 }
502 }
503 }
504 size += self.__buffa_unknown_fields.encoded_len() as u32;
505 size
506 }
507 fn write_to(
508 &self,
509 __cache: &mut ::buffa::SizeCache,
510 buf: &mut impl ::buffa::bytes::BufMut,
511 ) {
512 #[allow(unused_imports)]
513 use ::buffa::Enumeration as _;
514 if let ::core::option::Option::Some(ref v) = self.kind {
515 match v {
516 __buffa::oneof::cell::Kind::NullValue(x) => {
517 ::buffa::encoding::Tag::new(
518 1u32,
519 ::buffa::encoding::WireType::LengthDelimited,
520 )
521 .encode(buf);
522 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
523 x.write_to(__cache, buf);
524 }
525 __buffa::oneof::cell::Kind::Int64Value(x) => {
526 ::buffa::encoding::Tag::new(
527 2u32,
528 ::buffa::encoding::WireType::Varint,
529 )
530 .encode(buf);
531 ::buffa::types::encode_int64(*x, buf);
532 }
533 __buffa::oneof::cell::Kind::Uint64Value(x) => {
534 ::buffa::encoding::Tag::new(
535 3u32,
536 ::buffa::encoding::WireType::Varint,
537 )
538 .encode(buf);
539 ::buffa::types::encode_uint64(*x, buf);
540 }
541 __buffa::oneof::cell::Kind::Float64Value(x) => {
542 ::buffa::encoding::Tag::new(
543 4u32,
544 ::buffa::encoding::WireType::Fixed64,
545 )
546 .encode(buf);
547 ::buffa::types::encode_double(*x, buf);
548 }
549 __buffa::oneof::cell::Kind::BooleanValue(x) => {
550 ::buffa::encoding::Tag::new(
551 5u32,
552 ::buffa::encoding::WireType::Varint,
553 )
554 .encode(buf);
555 ::buffa::types::encode_bool(*x, buf);
556 }
557 __buffa::oneof::cell::Kind::Utf8Value(x) => {
558 ::buffa::encoding::Tag::new(
559 6u32,
560 ::buffa::encoding::WireType::LengthDelimited,
561 )
562 .encode(buf);
563 ::buffa::types::encode_string(x, buf);
564 }
565 __buffa::oneof::cell::Kind::FixedSizeBinaryValue(x) => {
566 ::buffa::encoding::Tag::new(
567 7u32,
568 ::buffa::encoding::WireType::LengthDelimited,
569 )
570 .encode(buf);
571 ::buffa::types::encode_bytes(x, buf);
572 }
573 __buffa::oneof::cell::Kind::Date32Value(x) => {
574 ::buffa::encoding::Tag::new(
575 8u32,
576 ::buffa::encoding::WireType::Varint,
577 )
578 .encode(buf);
579 ::buffa::types::encode_int32(*x, buf);
580 }
581 __buffa::oneof::cell::Kind::Date64Value(x) => {
582 ::buffa::encoding::Tag::new(
583 9u32,
584 ::buffa::encoding::WireType::Varint,
585 )
586 .encode(buf);
587 ::buffa::types::encode_int64(*x, buf);
588 }
589 __buffa::oneof::cell::Kind::TimestampValue(x) => {
590 ::buffa::encoding::Tag::new(
591 10u32,
592 ::buffa::encoding::WireType::Varint,
593 )
594 .encode(buf);
595 ::buffa::types::encode_int64(*x, buf);
596 }
597 __buffa::oneof::cell::Kind::Decimal128Value(x) => {
598 ::buffa::encoding::Tag::new(
599 11u32,
600 ::buffa::encoding::WireType::LengthDelimited,
601 )
602 .encode(buf);
603 ::buffa::types::encode_bytes(x, buf);
604 }
605 __buffa::oneof::cell::Kind::Decimal256Value(x) => {
606 ::buffa::encoding::Tag::new(
607 12u32,
608 ::buffa::encoding::WireType::LengthDelimited,
609 )
610 .encode(buf);
611 ::buffa::types::encode_bytes(x, buf);
612 }
613 __buffa::oneof::cell::Kind::ListValue(x) => {
614 ::buffa::encoding::Tag::new(
615 13u32,
616 ::buffa::encoding::WireType::LengthDelimited,
617 )
618 .encode(buf);
619 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
620 x.write_to(__cache, buf);
621 }
622 __buffa::oneof::cell::Kind::BinaryValue(x) => {
623 ::buffa::encoding::Tag::new(
624 14u32,
625 ::buffa::encoding::WireType::LengthDelimited,
626 )
627 .encode(buf);
628 ::buffa::types::encode_bytes(x, buf);
629 }
630 }
631 }
632 self.__buffa_unknown_fields.write_to(buf);
633 }
634 fn merge_field(
635 &mut self,
636 tag: ::buffa::encoding::Tag,
637 buf: &mut impl ::buffa::bytes::Buf,
638 depth: u32,
639 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
640 #[allow(unused_imports)]
641 use ::buffa::bytes::Buf as _;
642 #[allow(unused_imports)]
643 use ::buffa::Enumeration as _;
644 match tag.field_number() {
645 1u32 => {
646 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
647 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
648 field_number: 1u32,
649 expected: 2u8,
650 actual: tag.wire_type() as u8,
651 });
652 }
653 if let ::core::option::Option::Some(
654 __buffa::oneof::cell::Kind::NullValue(ref mut existing),
655 ) = self.kind
656 {
657 ::buffa::Message::merge_length_delimited(
658 &mut **existing,
659 buf,
660 depth,
661 )?;
662 } else {
663 let mut val = ::core::default::Default::default();
664 ::buffa::Message::merge_length_delimited(&mut val, buf, depth)?;
665 self.kind = ::core::option::Option::Some(
666 __buffa::oneof::cell::Kind::NullValue(
667 ::buffa::alloc::boxed::Box::new(val),
668 ),
669 );
670 }
671 }
672 2u32 => {
673 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
674 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
675 field_number: 2u32,
676 expected: 0u8,
677 actual: tag.wire_type() as u8,
678 });
679 }
680 self.kind = ::core::option::Option::Some(
681 __buffa::oneof::cell::Kind::Int64Value(
682 ::buffa::types::decode_int64(buf)?,
683 ),
684 );
685 }
686 3u32 => {
687 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
688 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
689 field_number: 3u32,
690 expected: 0u8,
691 actual: tag.wire_type() as u8,
692 });
693 }
694 self.kind = ::core::option::Option::Some(
695 __buffa::oneof::cell::Kind::Uint64Value(
696 ::buffa::types::decode_uint64(buf)?,
697 ),
698 );
699 }
700 4u32 => {
701 if tag.wire_type() != ::buffa::encoding::WireType::Fixed64 {
702 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
703 field_number: 4u32,
704 expected: 1u8,
705 actual: tag.wire_type() as u8,
706 });
707 }
708 self.kind = ::core::option::Option::Some(
709 __buffa::oneof::cell::Kind::Float64Value(
710 ::buffa::types::decode_double(buf)?,
711 ),
712 );
713 }
714 5u32 => {
715 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
716 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
717 field_number: 5u32,
718 expected: 0u8,
719 actual: tag.wire_type() as u8,
720 });
721 }
722 self.kind = ::core::option::Option::Some(
723 __buffa::oneof::cell::Kind::BooleanValue(
724 ::buffa::types::decode_bool(buf)?,
725 ),
726 );
727 }
728 6u32 => {
729 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
730 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
731 field_number: 6u32,
732 expected: 2u8,
733 actual: tag.wire_type() as u8,
734 });
735 }
736 self.kind = ::core::option::Option::Some(
737 __buffa::oneof::cell::Kind::Utf8Value(
738 ::buffa::types::decode_string(buf)?,
739 ),
740 );
741 }
742 7u32 => {
743 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
744 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
745 field_number: 7u32,
746 expected: 2u8,
747 actual: tag.wire_type() as u8,
748 });
749 }
750 self.kind = ::core::option::Option::Some(
751 __buffa::oneof::cell::Kind::FixedSizeBinaryValue(
752 ::buffa::types::decode_bytes_to_bytes(buf)?,
753 ),
754 );
755 }
756 8u32 => {
757 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
758 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
759 field_number: 8u32,
760 expected: 0u8,
761 actual: tag.wire_type() as u8,
762 });
763 }
764 self.kind = ::core::option::Option::Some(
765 __buffa::oneof::cell::Kind::Date32Value(
766 ::buffa::types::decode_int32(buf)?,
767 ),
768 );
769 }
770 9u32 => {
771 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
772 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
773 field_number: 9u32,
774 expected: 0u8,
775 actual: tag.wire_type() as u8,
776 });
777 }
778 self.kind = ::core::option::Option::Some(
779 __buffa::oneof::cell::Kind::Date64Value(
780 ::buffa::types::decode_int64(buf)?,
781 ),
782 );
783 }
784 10u32 => {
785 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
786 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
787 field_number: 10u32,
788 expected: 0u8,
789 actual: tag.wire_type() as u8,
790 });
791 }
792 self.kind = ::core::option::Option::Some(
793 __buffa::oneof::cell::Kind::TimestampValue(
794 ::buffa::types::decode_int64(buf)?,
795 ),
796 );
797 }
798 11u32 => {
799 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
800 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
801 field_number: 11u32,
802 expected: 2u8,
803 actual: tag.wire_type() as u8,
804 });
805 }
806 self.kind = ::core::option::Option::Some(
807 __buffa::oneof::cell::Kind::Decimal128Value(
808 ::buffa::types::decode_bytes_to_bytes(buf)?,
809 ),
810 );
811 }
812 12u32 => {
813 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
814 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
815 field_number: 12u32,
816 expected: 2u8,
817 actual: tag.wire_type() as u8,
818 });
819 }
820 self.kind = ::core::option::Option::Some(
821 __buffa::oneof::cell::Kind::Decimal256Value(
822 ::buffa::types::decode_bytes_to_bytes(buf)?,
823 ),
824 );
825 }
826 13u32 => {
827 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
828 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
829 field_number: 13u32,
830 expected: 2u8,
831 actual: tag.wire_type() as u8,
832 });
833 }
834 if let ::core::option::Option::Some(
835 __buffa::oneof::cell::Kind::ListValue(ref mut existing),
836 ) = self.kind
837 {
838 ::buffa::Message::merge_length_delimited(
839 &mut **existing,
840 buf,
841 depth,
842 )?;
843 } else {
844 let mut val = ::core::default::Default::default();
845 ::buffa::Message::merge_length_delimited(&mut val, buf, depth)?;
846 self.kind = ::core::option::Option::Some(
847 __buffa::oneof::cell::Kind::ListValue(
848 ::buffa::alloc::boxed::Box::new(val),
849 ),
850 );
851 }
852 }
853 14u32 => {
854 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
855 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
856 field_number: 14u32,
857 expected: 2u8,
858 actual: tag.wire_type() as u8,
859 });
860 }
861 self.kind = ::core::option::Option::Some(
862 __buffa::oneof::cell::Kind::BinaryValue(
863 ::buffa::types::decode_bytes_to_bytes(buf)?,
864 ),
865 );
866 }
867 _ => {
868 self.__buffa_unknown_fields
869 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
870 }
871 }
872 ::core::result::Result::Ok(())
873 }
874 fn clear(&mut self) {
875 self.kind = ::core::option::Option::None;
876 self.__buffa_unknown_fields.clear();
877 }
878}
879impl ::buffa::ExtensionSet for Cell {
880 const PROTO_FQN: &'static str = "sql.v1.Cell";
881 fn unknown_fields(&self) -> &::buffa::UnknownFields {
882 &self.__buffa_unknown_fields
883 }
884 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
885 &mut self.__buffa_unknown_fields
886 }
887}
888impl<'de> serde::Deserialize<'de> for Cell {
889 fn deserialize<D: serde::Deserializer<'de>>(
890 d: D,
891 ) -> ::core::result::Result<Self, D::Error> {
892 struct _V;
893 impl<'de> serde::de::Visitor<'de> for _V {
894 type Value = Cell;
895 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
896 f.write_str("struct Cell")
897 }
898 #[allow(clippy::field_reassign_with_default)]
899 fn visit_map<A: serde::de::MapAccess<'de>>(
900 self,
901 mut map: A,
902 ) -> ::core::result::Result<Cell, A::Error> {
903 let mut __oneof_kind: ::core::option::Option<
904 __buffa::oneof::cell::Kind,
905 > = None;
906 while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
907 match key.as_str() {
908 "nullValue" | "null_value" => {
909 let v: ::core::option::Option<Null> = map
910 .next_value_seed(
911 ::buffa::json_helpers::NullableDeserializeSeed(
912 ::buffa::json_helpers::DefaultDeserializeSeed::<Null>::new(),
913 ),
914 )?;
915 if let Some(v) = v {
916 if __oneof_kind.is_some() {
917 return Err(
918 serde::de::Error::custom(
919 "multiple oneof fields set for 'kind'",
920 ),
921 );
922 }
923 __oneof_kind = Some(
924 __buffa::oneof::cell::Kind::NullValue(
925 ::buffa::alloc::boxed::Box::new(v),
926 ),
927 );
928 }
929 }
930 "int64Value" | "int64_value" => {
931 struct _DeserSeed;
932 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
933 type Value = i64;
934 fn deserialize<D: serde::Deserializer<'de>>(
935 self,
936 d: D,
937 ) -> ::core::result::Result<i64, D::Error> {
938 ::buffa::json_helpers::int64::deserialize(d)
939 }
940 }
941 let v: ::core::option::Option<i64> = map
942 .next_value_seed(
943 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
944 )?;
945 if let Some(v) = v {
946 if __oneof_kind.is_some() {
947 return Err(
948 serde::de::Error::custom(
949 "multiple oneof fields set for 'kind'",
950 ),
951 );
952 }
953 __oneof_kind = Some(
954 __buffa::oneof::cell::Kind::Int64Value(v),
955 );
956 }
957 }
958 "uint64Value" | "uint64_value" => {
959 struct _DeserSeed;
960 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
961 type Value = u64;
962 fn deserialize<D: serde::Deserializer<'de>>(
963 self,
964 d: D,
965 ) -> ::core::result::Result<u64, D::Error> {
966 ::buffa::json_helpers::uint64::deserialize(d)
967 }
968 }
969 let v: ::core::option::Option<u64> = map
970 .next_value_seed(
971 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
972 )?;
973 if let Some(v) = v {
974 if __oneof_kind.is_some() {
975 return Err(
976 serde::de::Error::custom(
977 "multiple oneof fields set for 'kind'",
978 ),
979 );
980 }
981 __oneof_kind = Some(
982 __buffa::oneof::cell::Kind::Uint64Value(v),
983 );
984 }
985 }
986 "float64Value" | "float64_value" => {
987 struct _DeserSeed;
988 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
989 type Value = f64;
990 fn deserialize<D: serde::Deserializer<'de>>(
991 self,
992 d: D,
993 ) -> ::core::result::Result<f64, D::Error> {
994 ::buffa::json_helpers::double::deserialize(d)
995 }
996 }
997 let v: ::core::option::Option<f64> = map
998 .next_value_seed(
999 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1000 )?;
1001 if let Some(v) = v {
1002 if __oneof_kind.is_some() {
1003 return Err(
1004 serde::de::Error::custom(
1005 "multiple oneof fields set for 'kind'",
1006 ),
1007 );
1008 }
1009 __oneof_kind = Some(
1010 __buffa::oneof::cell::Kind::Float64Value(v),
1011 );
1012 }
1013 }
1014 "booleanValue" | "boolean_value" => {
1015 let v: ::core::option::Option<bool> = map
1016 .next_value_seed(
1017 ::buffa::json_helpers::NullableDeserializeSeed(
1018 ::buffa::json_helpers::DefaultDeserializeSeed::<bool>::new(),
1019 ),
1020 )?;
1021 if let Some(v) = v {
1022 if __oneof_kind.is_some() {
1023 return Err(
1024 serde::de::Error::custom(
1025 "multiple oneof fields set for 'kind'",
1026 ),
1027 );
1028 }
1029 __oneof_kind = Some(
1030 __buffa::oneof::cell::Kind::BooleanValue(v),
1031 );
1032 }
1033 }
1034 "utf8Value" | "utf8_value" => {
1035 let v: ::core::option::Option<
1036 ::buffa::alloc::string::String,
1037 > = map
1038 .next_value_seed(
1039 ::buffa::json_helpers::NullableDeserializeSeed(
1040 ::buffa::json_helpers::DefaultDeserializeSeed::<
1041 ::buffa::alloc::string::String,
1042 >::new(),
1043 ),
1044 )?;
1045 if let Some(v) = v {
1046 if __oneof_kind.is_some() {
1047 return Err(
1048 serde::de::Error::custom(
1049 "multiple oneof fields set for 'kind'",
1050 ),
1051 );
1052 }
1053 __oneof_kind = Some(
1054 __buffa::oneof::cell::Kind::Utf8Value(v),
1055 );
1056 }
1057 }
1058 "fixedSizeBinaryValue" | "fixed_size_binary_value" => {
1059 struct _DeserSeed;
1060 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1061 type Value = ::buffa::bytes::Bytes;
1062 fn deserialize<D: serde::Deserializer<'de>>(
1063 self,
1064 d: D,
1065 ) -> ::core::result::Result<
1066 ::buffa::bytes::Bytes,
1067 D::Error,
1068 > {
1069 ::buffa::json_helpers::bytes::deserialize(d)
1070 }
1071 }
1072 let v: ::core::option::Option<::buffa::bytes::Bytes> = map
1073 .next_value_seed(
1074 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1075 )?;
1076 if let Some(v) = v {
1077 if __oneof_kind.is_some() {
1078 return Err(
1079 serde::de::Error::custom(
1080 "multiple oneof fields set for 'kind'",
1081 ),
1082 );
1083 }
1084 __oneof_kind = Some(
1085 __buffa::oneof::cell::Kind::FixedSizeBinaryValue(v),
1086 );
1087 }
1088 }
1089 "date32Value" | "date32_value" => {
1090 struct _DeserSeed;
1091 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1092 type Value = i32;
1093 fn deserialize<D: serde::Deserializer<'de>>(
1094 self,
1095 d: D,
1096 ) -> ::core::result::Result<i32, D::Error> {
1097 ::buffa::json_helpers::int32::deserialize(d)
1098 }
1099 }
1100 let v: ::core::option::Option<i32> = map
1101 .next_value_seed(
1102 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1103 )?;
1104 if let Some(v) = v {
1105 if __oneof_kind.is_some() {
1106 return Err(
1107 serde::de::Error::custom(
1108 "multiple oneof fields set for 'kind'",
1109 ),
1110 );
1111 }
1112 __oneof_kind = Some(
1113 __buffa::oneof::cell::Kind::Date32Value(v),
1114 );
1115 }
1116 }
1117 "date64Value" | "date64_value" => {
1118 struct _DeserSeed;
1119 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1120 type Value = i64;
1121 fn deserialize<D: serde::Deserializer<'de>>(
1122 self,
1123 d: D,
1124 ) -> ::core::result::Result<i64, D::Error> {
1125 ::buffa::json_helpers::int64::deserialize(d)
1126 }
1127 }
1128 let v: ::core::option::Option<i64> = map
1129 .next_value_seed(
1130 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1131 )?;
1132 if let Some(v) = v {
1133 if __oneof_kind.is_some() {
1134 return Err(
1135 serde::de::Error::custom(
1136 "multiple oneof fields set for 'kind'",
1137 ),
1138 );
1139 }
1140 __oneof_kind = Some(
1141 __buffa::oneof::cell::Kind::Date64Value(v),
1142 );
1143 }
1144 }
1145 "timestampValue" | "timestamp_value" => {
1146 struct _DeserSeed;
1147 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1148 type Value = i64;
1149 fn deserialize<D: serde::Deserializer<'de>>(
1150 self,
1151 d: D,
1152 ) -> ::core::result::Result<i64, D::Error> {
1153 ::buffa::json_helpers::int64::deserialize(d)
1154 }
1155 }
1156 let v: ::core::option::Option<i64> = map
1157 .next_value_seed(
1158 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1159 )?;
1160 if let Some(v) = v {
1161 if __oneof_kind.is_some() {
1162 return Err(
1163 serde::de::Error::custom(
1164 "multiple oneof fields set for 'kind'",
1165 ),
1166 );
1167 }
1168 __oneof_kind = Some(
1169 __buffa::oneof::cell::Kind::TimestampValue(v),
1170 );
1171 }
1172 }
1173 "decimal128Value" | "decimal128_value" => {
1174 struct _DeserSeed;
1175 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1176 type Value = ::buffa::bytes::Bytes;
1177 fn deserialize<D: serde::Deserializer<'de>>(
1178 self,
1179 d: D,
1180 ) -> ::core::result::Result<
1181 ::buffa::bytes::Bytes,
1182 D::Error,
1183 > {
1184 ::buffa::json_helpers::bytes::deserialize(d)
1185 }
1186 }
1187 let v: ::core::option::Option<::buffa::bytes::Bytes> = map
1188 .next_value_seed(
1189 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1190 )?;
1191 if let Some(v) = v {
1192 if __oneof_kind.is_some() {
1193 return Err(
1194 serde::de::Error::custom(
1195 "multiple oneof fields set for 'kind'",
1196 ),
1197 );
1198 }
1199 __oneof_kind = Some(
1200 __buffa::oneof::cell::Kind::Decimal128Value(v),
1201 );
1202 }
1203 }
1204 "decimal256Value" | "decimal256_value" => {
1205 struct _DeserSeed;
1206 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1207 type Value = ::buffa::bytes::Bytes;
1208 fn deserialize<D: serde::Deserializer<'de>>(
1209 self,
1210 d: D,
1211 ) -> ::core::result::Result<
1212 ::buffa::bytes::Bytes,
1213 D::Error,
1214 > {
1215 ::buffa::json_helpers::bytes::deserialize(d)
1216 }
1217 }
1218 let v: ::core::option::Option<::buffa::bytes::Bytes> = map
1219 .next_value_seed(
1220 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1221 )?;
1222 if let Some(v) = v {
1223 if __oneof_kind.is_some() {
1224 return Err(
1225 serde::de::Error::custom(
1226 "multiple oneof fields set for 'kind'",
1227 ),
1228 );
1229 }
1230 __oneof_kind = Some(
1231 __buffa::oneof::cell::Kind::Decimal256Value(v),
1232 );
1233 }
1234 }
1235 "listValue" | "list_value" => {
1236 let v: ::core::option::Option<ListValue> = map
1237 .next_value_seed(
1238 ::buffa::json_helpers::NullableDeserializeSeed(
1239 ::buffa::json_helpers::DefaultDeserializeSeed::<
1240 ListValue,
1241 >::new(),
1242 ),
1243 )?;
1244 if let Some(v) = v {
1245 if __oneof_kind.is_some() {
1246 return Err(
1247 serde::de::Error::custom(
1248 "multiple oneof fields set for 'kind'",
1249 ),
1250 );
1251 }
1252 __oneof_kind = Some(
1253 __buffa::oneof::cell::Kind::ListValue(
1254 ::buffa::alloc::boxed::Box::new(v),
1255 ),
1256 );
1257 }
1258 }
1259 "binaryValue" | "binary_value" => {
1260 struct _DeserSeed;
1261 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1262 type Value = ::buffa::bytes::Bytes;
1263 fn deserialize<D: serde::Deserializer<'de>>(
1264 self,
1265 d: D,
1266 ) -> ::core::result::Result<
1267 ::buffa::bytes::Bytes,
1268 D::Error,
1269 > {
1270 ::buffa::json_helpers::bytes::deserialize(d)
1271 }
1272 }
1273 let v: ::core::option::Option<::buffa::bytes::Bytes> = map
1274 .next_value_seed(
1275 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1276 )?;
1277 if let Some(v) = v {
1278 if __oneof_kind.is_some() {
1279 return Err(
1280 serde::de::Error::custom(
1281 "multiple oneof fields set for 'kind'",
1282 ),
1283 );
1284 }
1285 __oneof_kind = Some(
1286 __buffa::oneof::cell::Kind::BinaryValue(v),
1287 );
1288 }
1289 }
1290 _ => {
1291 map.next_value::<serde::de::IgnoredAny>()?;
1292 }
1293 }
1294 }
1295 let mut __r = <Cell as ::core::default::Default>::default();
1296 __r.kind = __oneof_kind;
1297 Ok(__r)
1298 }
1299 }
1300 d.deserialize_map(_V)
1301 }
1302}
1303impl ::buffa::json_helpers::ProtoElemJson for Cell {
1304 fn serialize_proto_json<S: ::serde::Serializer>(
1305 v: &Self,
1306 s: S,
1307 ) -> ::core::result::Result<S::Ok, S::Error> {
1308 ::serde::Serialize::serialize(v, s)
1309 }
1310 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1311 d: D,
1312 ) -> ::core::result::Result<Self, D::Error> {
1313 <Self as ::serde::Deserialize>::deserialize(d)
1314 }
1315}
1316#[doc(hidden)]
1317pub const __CELL_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1318 type_url: "type.googleapis.com/sql.v1.Cell",
1319 to_json: ::buffa::type_registry::any_to_json::<Cell>,
1320 from_json: ::buffa::type_registry::any_from_json::<Cell>,
1321 is_wkt: false,
1322};
1323pub mod cell {
1324 #[allow(unused_imports)]
1325 use super::*;
1326 #[doc(inline)]
1327 pub use super::__buffa::oneof::cell::Kind;
1328 #[doc(inline)]
1329 pub use super::__buffa::view::oneof::cell::Kind as KindView;
1330}
1331#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
1333#[repr(i32)]
1334pub enum IndexLayout {
1335 INDEX_LAYOUT_LEXICOGRAPHIC = 0i32,
1337 INDEX_LAYOUT_Z_ORDER = 1i32,
1340}
1341impl ::core::default::Default for IndexLayout {
1342 fn default() -> Self {
1343 Self::INDEX_LAYOUT_LEXICOGRAPHIC
1344 }
1345}
1346impl ::serde::Serialize for IndexLayout {
1347 fn serialize<S: ::serde::Serializer>(
1348 &self,
1349 s: S,
1350 ) -> ::core::result::Result<S::Ok, S::Error> {
1351 s.serialize_str(::buffa::Enumeration::proto_name(self))
1352 }
1353}
1354impl<'de> ::serde::Deserialize<'de> for IndexLayout {
1355 fn deserialize<D: ::serde::Deserializer<'de>>(
1356 d: D,
1357 ) -> ::core::result::Result<Self, D::Error> {
1358 struct _V;
1359 impl ::serde::de::Visitor<'_> for _V {
1360 type Value = IndexLayout;
1361 fn expecting(
1362 &self,
1363 f: &mut ::core::fmt::Formatter<'_>,
1364 ) -> ::core::fmt::Result {
1365 f.write_str(
1366 concat!("a string, integer, or null for ", stringify!(IndexLayout)),
1367 )
1368 }
1369 fn visit_str<E: ::serde::de::Error>(
1370 self,
1371 v: &str,
1372 ) -> ::core::result::Result<IndexLayout, E> {
1373 <IndexLayout as ::buffa::Enumeration>::from_proto_name(v)
1374 .ok_or_else(|| { ::serde::de::Error::unknown_variant(v, &[]) })
1375 }
1376 fn visit_i64<E: ::serde::de::Error>(
1377 self,
1378 v: i64,
1379 ) -> ::core::result::Result<IndexLayout, E> {
1380 let v32 = i32::try_from(v)
1381 .map_err(|_| {
1382 ::serde::de::Error::custom(
1383 ::buffa::alloc::format!("enum value {v} out of i32 range"),
1384 )
1385 })?;
1386 <IndexLayout as ::buffa::Enumeration>::from_i32(v32)
1387 .ok_or_else(|| {
1388 ::serde::de::Error::custom(
1389 ::buffa::alloc::format!("unknown enum value {v32}"),
1390 )
1391 })
1392 }
1393 fn visit_u64<E: ::serde::de::Error>(
1394 self,
1395 v: u64,
1396 ) -> ::core::result::Result<IndexLayout, E> {
1397 let v32 = i32::try_from(v)
1398 .map_err(|_| {
1399 ::serde::de::Error::custom(
1400 ::buffa::alloc::format!("enum value {v} out of i32 range"),
1401 )
1402 })?;
1403 <IndexLayout as ::buffa::Enumeration>::from_i32(v32)
1404 .ok_or_else(|| {
1405 ::serde::de::Error::custom(
1406 ::buffa::alloc::format!("unknown enum value {v32}"),
1407 )
1408 })
1409 }
1410 fn visit_unit<E: ::serde::de::Error>(
1411 self,
1412 ) -> ::core::result::Result<IndexLayout, E> {
1413 ::core::result::Result::Ok(::core::default::Default::default())
1414 }
1415 }
1416 d.deserialize_any(_V)
1417 }
1418}
1419impl ::buffa::json_helpers::ProtoElemJson for IndexLayout {
1420 fn serialize_proto_json<S: ::serde::Serializer>(
1421 v: &Self,
1422 s: S,
1423 ) -> ::core::result::Result<S::Ok, S::Error> {
1424 ::serde::Serialize::serialize(v, s)
1425 }
1426 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1427 d: D,
1428 ) -> ::core::result::Result<Self, D::Error> {
1429 <Self as ::serde::Deserialize>::deserialize(d)
1430 }
1431}
1432impl ::buffa::Enumeration for IndexLayout {
1433 fn from_i32(value: i32) -> ::core::option::Option<Self> {
1434 match value {
1435 0i32 => ::core::option::Option::Some(Self::INDEX_LAYOUT_LEXICOGRAPHIC),
1436 1i32 => ::core::option::Option::Some(Self::INDEX_LAYOUT_Z_ORDER),
1437 _ => ::core::option::Option::None,
1438 }
1439 }
1440 fn to_i32(&self) -> i32 {
1441 *self as i32
1442 }
1443 fn proto_name(&self) -> &'static str {
1444 match self {
1445 Self::INDEX_LAYOUT_LEXICOGRAPHIC => "INDEX_LAYOUT_LEXICOGRAPHIC",
1446 Self::INDEX_LAYOUT_Z_ORDER => "INDEX_LAYOUT_Z_ORDER",
1447 }
1448 }
1449 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
1450 match name {
1451 "INDEX_LAYOUT_LEXICOGRAPHIC" => {
1452 ::core::option::Option::Some(Self::INDEX_LAYOUT_LEXICOGRAPHIC)
1453 }
1454 "INDEX_LAYOUT_Z_ORDER" => {
1455 ::core::option::Option::Some(Self::INDEX_LAYOUT_Z_ORDER)
1456 }
1457 _ => ::core::option::Option::None,
1458 }
1459 }
1460 fn values() -> &'static [Self] {
1461 &[Self::INDEX_LAYOUT_LEXICOGRAPHIC, Self::INDEX_LAYOUT_Z_ORDER]
1462 }
1463}
1464#[derive(Clone, PartialEq, Default)]
1466#[derive(::serde::Serialize, ::serde::Deserialize)]
1467#[serde(default)]
1468pub struct TablesResponse {
1469 #[serde(
1471 rename = "tables",
1472 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1473 deserialize_with = "::buffa::json_helpers::null_as_default"
1474 )]
1475 pub tables: ::buffa::alloc::vec::Vec<Table>,
1476 #[serde(skip)]
1477 #[doc(hidden)]
1478 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1479}
1480impl ::core::fmt::Debug for TablesResponse {
1481 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1482 f.debug_struct("TablesResponse").field("tables", &self.tables).finish()
1483 }
1484}
1485impl TablesResponse {
1486 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesResponse";
1491}
1492impl ::buffa::DefaultInstance for TablesResponse {
1493 fn default_instance() -> &'static Self {
1494 static VALUE: ::buffa::__private::OnceBox<TablesResponse> = ::buffa::__private::OnceBox::new();
1495 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
1496 }
1497}
1498impl ::buffa::MessageName for TablesResponse {
1499 const PACKAGE: &'static str = "sql.v1";
1500 const NAME: &'static str = "TablesResponse";
1501 const FULL_NAME: &'static str = "sql.v1.TablesResponse";
1502 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesResponse";
1503}
1504impl ::buffa::Message for TablesResponse {
1505 #[allow(clippy::let_and_return)]
1511 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1512 #[allow(unused_imports)]
1513 use ::buffa::Enumeration as _;
1514 let mut size = 0u32;
1515 for v in &self.tables {
1516 let __slot = __cache.reserve();
1517 let inner_size = v.compute_size(__cache);
1518 __cache.set(__slot, inner_size);
1519 size
1520 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1521 + inner_size;
1522 }
1523 size += self.__buffa_unknown_fields.encoded_len() as u32;
1524 size
1525 }
1526 fn write_to(
1527 &self,
1528 __cache: &mut ::buffa::SizeCache,
1529 buf: &mut impl ::buffa::bytes::BufMut,
1530 ) {
1531 #[allow(unused_imports)]
1532 use ::buffa::Enumeration as _;
1533 for v in &self.tables {
1534 ::buffa::encoding::Tag::new(
1535 1u32,
1536 ::buffa::encoding::WireType::LengthDelimited,
1537 )
1538 .encode(buf);
1539 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
1540 v.write_to(__cache, buf);
1541 }
1542 self.__buffa_unknown_fields.write_to(buf);
1543 }
1544 fn merge_field(
1545 &mut self,
1546 tag: ::buffa::encoding::Tag,
1547 buf: &mut impl ::buffa::bytes::Buf,
1548 depth: u32,
1549 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1550 #[allow(unused_imports)]
1551 use ::buffa::bytes::Buf as _;
1552 #[allow(unused_imports)]
1553 use ::buffa::Enumeration as _;
1554 match tag.field_number() {
1555 1u32 => {
1556 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1557 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1558 field_number: 1u32,
1559 expected: 2u8,
1560 actual: tag.wire_type() as u8,
1561 });
1562 }
1563 let mut elem = ::core::default::Default::default();
1564 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1565 self.tables.push(elem);
1566 }
1567 _ => {
1568 self.__buffa_unknown_fields
1569 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1570 }
1571 }
1572 ::core::result::Result::Ok(())
1573 }
1574 fn clear(&mut self) {
1575 self.tables.clear();
1576 self.__buffa_unknown_fields.clear();
1577 }
1578}
1579impl ::buffa::ExtensionSet for TablesResponse {
1580 const PROTO_FQN: &'static str = "sql.v1.TablesResponse";
1581 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1582 &self.__buffa_unknown_fields
1583 }
1584 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1585 &mut self.__buffa_unknown_fields
1586 }
1587}
1588impl ::buffa::json_helpers::ProtoElemJson for TablesResponse {
1589 fn serialize_proto_json<S: ::serde::Serializer>(
1590 v: &Self,
1591 s: S,
1592 ) -> ::core::result::Result<S::Ok, S::Error> {
1593 ::serde::Serialize::serialize(v, s)
1594 }
1595 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1596 d: D,
1597 ) -> ::core::result::Result<Self, D::Error> {
1598 <Self as ::serde::Deserialize>::deserialize(d)
1599 }
1600}
1601#[doc(hidden)]
1602pub const __TABLES_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1603 type_url: "type.googleapis.com/sql.v1.TablesResponse",
1604 to_json: ::buffa::type_registry::any_to_json::<TablesResponse>,
1605 from_json: ::buffa::type_registry::any_from_json::<TablesResponse>,
1606 is_wkt: false,
1607};
1608#[derive(Clone, PartialEq, Default)]
1610#[derive(::serde::Serialize, ::serde::Deserialize)]
1611#[serde(default)]
1612pub struct TablesRequest {
1613 #[serde(skip)]
1614 #[doc(hidden)]
1615 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1616}
1617impl ::core::fmt::Debug for TablesRequest {
1618 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1619 f.debug_struct("TablesRequest").finish()
1620 }
1621}
1622impl TablesRequest {
1623 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesRequest";
1628}
1629impl ::buffa::DefaultInstance for TablesRequest {
1630 fn default_instance() -> &'static Self {
1631 static VALUE: ::buffa::__private::OnceBox<TablesRequest> = ::buffa::__private::OnceBox::new();
1632 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
1633 }
1634}
1635impl ::buffa::MessageName for TablesRequest {
1636 const PACKAGE: &'static str = "sql.v1";
1637 const NAME: &'static str = "TablesRequest";
1638 const FULL_NAME: &'static str = "sql.v1.TablesRequest";
1639 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesRequest";
1640}
1641impl ::buffa::Message for TablesRequest {
1642 #[allow(clippy::let_and_return)]
1648 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
1649 #[allow(unused_imports)]
1650 use ::buffa::Enumeration as _;
1651 let mut size = 0u32;
1652 size += self.__buffa_unknown_fields.encoded_len() as u32;
1653 size
1654 }
1655 fn write_to(
1656 &self,
1657 _cache: &mut ::buffa::SizeCache,
1658 buf: &mut impl ::buffa::bytes::BufMut,
1659 ) {
1660 #[allow(unused_imports)]
1661 use ::buffa::Enumeration as _;
1662 self.__buffa_unknown_fields.write_to(buf);
1663 }
1664 fn merge_field(
1665 &mut self,
1666 tag: ::buffa::encoding::Tag,
1667 buf: &mut impl ::buffa::bytes::Buf,
1668 depth: u32,
1669 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1670 #[allow(unused_imports)]
1671 use ::buffa::bytes::Buf as _;
1672 #[allow(unused_imports)]
1673 use ::buffa::Enumeration as _;
1674 match tag.field_number() {
1675 _ => {
1676 self.__buffa_unknown_fields
1677 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1678 }
1679 }
1680 ::core::result::Result::Ok(())
1681 }
1682 fn clear(&mut self) {
1683 self.__buffa_unknown_fields.clear();
1684 }
1685}
1686impl ::buffa::ExtensionSet for TablesRequest {
1687 const PROTO_FQN: &'static str = "sql.v1.TablesRequest";
1688 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1689 &self.__buffa_unknown_fields
1690 }
1691 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1692 &mut self.__buffa_unknown_fields
1693 }
1694}
1695impl ::buffa::json_helpers::ProtoElemJson for TablesRequest {
1696 fn serialize_proto_json<S: ::serde::Serializer>(
1697 v: &Self,
1698 s: S,
1699 ) -> ::core::result::Result<S::Ok, S::Error> {
1700 ::serde::Serialize::serialize(v, s)
1701 }
1702 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1703 d: D,
1704 ) -> ::core::result::Result<Self, D::Error> {
1705 <Self as ::serde::Deserialize>::deserialize(d)
1706 }
1707}
1708#[doc(hidden)]
1709pub const __TABLES_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1710 type_url: "type.googleapis.com/sql.v1.TablesRequest",
1711 to_json: ::buffa::type_registry::any_to_json::<TablesRequest>,
1712 from_json: ::buffa::type_registry::any_from_json::<TablesRequest>,
1713 is_wkt: false,
1714};
1715#[derive(Clone, PartialEq, Default)]
1717#[derive(::serde::Serialize, ::serde::Deserialize)]
1718#[serde(default)]
1719pub struct Table {
1720 #[serde(
1724 rename = "name",
1725 with = "::buffa::json_helpers::proto_string",
1726 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
1727 )]
1728 pub name: ::buffa::alloc::string::String,
1729 #[serde(
1733 rename = "columns",
1734 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1735 deserialize_with = "::buffa::json_helpers::null_as_default"
1736 )]
1737 pub columns: ::buffa::alloc::vec::Vec<Column>,
1738 #[serde(
1742 rename = "primaryKeyColumns",
1743 alias = "primary_key_columns",
1744 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1745 deserialize_with = "::buffa::json_helpers::null_as_default"
1746 )]
1747 pub primary_key_columns: ::buffa::alloc::vec::Vec<u32>,
1748 #[serde(
1752 rename = "indexes",
1753 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1754 deserialize_with = "::buffa::json_helpers::null_as_default"
1755 )]
1756 pub indexes: ::buffa::alloc::vec::Vec<Index>,
1757 #[serde(skip)]
1758 #[doc(hidden)]
1759 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1760}
1761impl ::core::fmt::Debug for Table {
1762 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1763 f.debug_struct("Table")
1764 .field("name", &self.name)
1765 .field("columns", &self.columns)
1766 .field("primary_key_columns", &self.primary_key_columns)
1767 .field("indexes", &self.indexes)
1768 .finish()
1769 }
1770}
1771impl Table {
1772 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Table";
1777}
1778impl ::buffa::DefaultInstance for Table {
1779 fn default_instance() -> &'static Self {
1780 static VALUE: ::buffa::__private::OnceBox<Table> = ::buffa::__private::OnceBox::new();
1781 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
1782 }
1783}
1784impl ::buffa::MessageName for Table {
1785 const PACKAGE: &'static str = "sql.v1";
1786 const NAME: &'static str = "Table";
1787 const FULL_NAME: &'static str = "sql.v1.Table";
1788 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Table";
1789}
1790impl ::buffa::Message for Table {
1791 #[allow(clippy::let_and_return)]
1797 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1798 #[allow(unused_imports)]
1799 use ::buffa::Enumeration as _;
1800 let mut size = 0u32;
1801 if !self.name.is_empty() {
1802 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
1803 }
1804 for v in &self.columns {
1805 let __slot = __cache.reserve();
1806 let inner_size = v.compute_size(__cache);
1807 __cache.set(__slot, inner_size);
1808 size
1809 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1810 + inner_size;
1811 }
1812 if !self.primary_key_columns.is_empty() {
1813 let payload: u32 = self
1814 .primary_key_columns
1815 .iter()
1816 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
1817 .sum::<u32>();
1818 size
1819 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
1820 }
1821 for v in &self.indexes {
1822 let __slot = __cache.reserve();
1823 let inner_size = v.compute_size(__cache);
1824 __cache.set(__slot, inner_size);
1825 size
1826 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1827 + inner_size;
1828 }
1829 size += self.__buffa_unknown_fields.encoded_len() as u32;
1830 size
1831 }
1832 fn write_to(
1833 &self,
1834 __cache: &mut ::buffa::SizeCache,
1835 buf: &mut impl ::buffa::bytes::BufMut,
1836 ) {
1837 #[allow(unused_imports)]
1838 use ::buffa::Enumeration as _;
1839 if !self.name.is_empty() {
1840 ::buffa::encoding::Tag::new(
1841 1u32,
1842 ::buffa::encoding::WireType::LengthDelimited,
1843 )
1844 .encode(buf);
1845 ::buffa::types::encode_string(&self.name, buf);
1846 }
1847 for v in &self.columns {
1848 ::buffa::encoding::Tag::new(
1849 2u32,
1850 ::buffa::encoding::WireType::LengthDelimited,
1851 )
1852 .encode(buf);
1853 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
1854 v.write_to(__cache, buf);
1855 }
1856 if !self.primary_key_columns.is_empty() {
1857 let payload: u32 = self
1858 .primary_key_columns
1859 .iter()
1860 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
1861 .sum::<u32>();
1862 ::buffa::encoding::Tag::new(
1863 3u32,
1864 ::buffa::encoding::WireType::LengthDelimited,
1865 )
1866 .encode(buf);
1867 ::buffa::encoding::encode_varint(payload as u64, buf);
1868 for &v in &self.primary_key_columns {
1869 ::buffa::types::encode_uint32(v, buf);
1870 }
1871 }
1872 for v in &self.indexes {
1873 ::buffa::encoding::Tag::new(
1874 4u32,
1875 ::buffa::encoding::WireType::LengthDelimited,
1876 )
1877 .encode(buf);
1878 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
1879 v.write_to(__cache, buf);
1880 }
1881 self.__buffa_unknown_fields.write_to(buf);
1882 }
1883 fn merge_field(
1884 &mut self,
1885 tag: ::buffa::encoding::Tag,
1886 buf: &mut impl ::buffa::bytes::Buf,
1887 depth: u32,
1888 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1889 #[allow(unused_imports)]
1890 use ::buffa::bytes::Buf as _;
1891 #[allow(unused_imports)]
1892 use ::buffa::Enumeration as _;
1893 match tag.field_number() {
1894 1u32 => {
1895 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1896 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1897 field_number: 1u32,
1898 expected: 2u8,
1899 actual: tag.wire_type() as u8,
1900 });
1901 }
1902 ::buffa::types::merge_string(&mut self.name, buf)?;
1903 }
1904 2u32 => {
1905 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1906 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1907 field_number: 2u32,
1908 expected: 2u8,
1909 actual: tag.wire_type() as u8,
1910 });
1911 }
1912 let mut elem = ::core::default::Default::default();
1913 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1914 self.columns.push(elem);
1915 }
1916 3u32 => {
1917 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
1918 let len = ::buffa::encoding::decode_varint(buf)?;
1919 let len = usize::try_from(len)
1920 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
1921 if buf.remaining() < len {
1922 return ::core::result::Result::Err(
1923 ::buffa::DecodeError::UnexpectedEof,
1924 );
1925 }
1926 self.primary_key_columns.reserve(len);
1927 let mut limited = buf.take(len);
1928 while limited.has_remaining() {
1929 self.primary_key_columns
1930 .push(::buffa::types::decode_uint32(&mut limited)?);
1931 }
1932 let leftover = limited.remaining();
1933 if leftover > 0 {
1934 limited.advance(leftover);
1935 }
1936 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
1937 self.primary_key_columns.push(::buffa::types::decode_uint32(buf)?);
1938 } else {
1939 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1940 field_number: 3u32,
1941 expected: 2u8,
1942 actual: tag.wire_type() as u8,
1943 });
1944 }
1945 }
1946 4u32 => {
1947 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1948 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1949 field_number: 4u32,
1950 expected: 2u8,
1951 actual: tag.wire_type() as u8,
1952 });
1953 }
1954 let mut elem = ::core::default::Default::default();
1955 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1956 self.indexes.push(elem);
1957 }
1958 _ => {
1959 self.__buffa_unknown_fields
1960 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1961 }
1962 }
1963 ::core::result::Result::Ok(())
1964 }
1965 fn clear(&mut self) {
1966 self.name.clear();
1967 self.columns.clear();
1968 self.primary_key_columns.clear();
1969 self.indexes.clear();
1970 self.__buffa_unknown_fields.clear();
1971 }
1972}
1973impl ::buffa::ExtensionSet for Table {
1974 const PROTO_FQN: &'static str = "sql.v1.Table";
1975 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1976 &self.__buffa_unknown_fields
1977 }
1978 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1979 &mut self.__buffa_unknown_fields
1980 }
1981}
1982impl ::buffa::json_helpers::ProtoElemJson for Table {
1983 fn serialize_proto_json<S: ::serde::Serializer>(
1984 v: &Self,
1985 s: S,
1986 ) -> ::core::result::Result<S::Ok, S::Error> {
1987 ::serde::Serialize::serialize(v, s)
1988 }
1989 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1990 d: D,
1991 ) -> ::core::result::Result<Self, D::Error> {
1992 <Self as ::serde::Deserialize>::deserialize(d)
1993 }
1994}
1995#[doc(hidden)]
1996pub const __TABLE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1997 type_url: "type.googleapis.com/sql.v1.Table",
1998 to_json: ::buffa::type_registry::any_to_json::<Table>,
1999 from_json: ::buffa::type_registry::any_from_json::<Table>,
2000 is_wkt: false,
2001};
2002#[derive(Clone, PartialEq, Default)]
2004#[derive(::serde::Serialize, ::serde::Deserialize)]
2005#[serde(default)]
2006pub struct Column {
2007 #[serde(
2009 rename = "name",
2010 with = "::buffa::json_helpers::proto_string",
2011 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2012 )]
2013 pub name: ::buffa::alloc::string::String,
2014 #[serde(
2020 rename = "dataType",
2021 alias = "data_type",
2022 with = "::buffa::json_helpers::proto_string",
2023 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2024 )]
2025 pub data_type: ::buffa::alloc::string::String,
2026 #[serde(
2028 rename = "nullable",
2029 with = "::buffa::json_helpers::proto_bool",
2030 skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
2031 )]
2032 pub nullable: bool,
2033 #[serde(skip)]
2034 #[doc(hidden)]
2035 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2036}
2037impl ::core::fmt::Debug for Column {
2038 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2039 f.debug_struct("Column")
2040 .field("name", &self.name)
2041 .field("data_type", &self.data_type)
2042 .field("nullable", &self.nullable)
2043 .finish()
2044 }
2045}
2046impl Column {
2047 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Column";
2052}
2053impl ::buffa::DefaultInstance for Column {
2054 fn default_instance() -> &'static Self {
2055 static VALUE: ::buffa::__private::OnceBox<Column> = ::buffa::__private::OnceBox::new();
2056 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2057 }
2058}
2059impl ::buffa::MessageName for Column {
2060 const PACKAGE: &'static str = "sql.v1";
2061 const NAME: &'static str = "Column";
2062 const FULL_NAME: &'static str = "sql.v1.Column";
2063 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Column";
2064}
2065impl ::buffa::Message for Column {
2066 #[allow(clippy::let_and_return)]
2072 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
2073 #[allow(unused_imports)]
2074 use ::buffa::Enumeration as _;
2075 let mut size = 0u32;
2076 if !self.name.is_empty() {
2077 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
2078 }
2079 if !self.data_type.is_empty() {
2080 size += 1u32 + ::buffa::types::string_encoded_len(&self.data_type) as u32;
2081 }
2082 if self.nullable {
2083 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
2084 }
2085 size += self.__buffa_unknown_fields.encoded_len() as u32;
2086 size
2087 }
2088 fn write_to(
2089 &self,
2090 _cache: &mut ::buffa::SizeCache,
2091 buf: &mut impl ::buffa::bytes::BufMut,
2092 ) {
2093 #[allow(unused_imports)]
2094 use ::buffa::Enumeration as _;
2095 if !self.name.is_empty() {
2096 ::buffa::encoding::Tag::new(
2097 1u32,
2098 ::buffa::encoding::WireType::LengthDelimited,
2099 )
2100 .encode(buf);
2101 ::buffa::types::encode_string(&self.name, buf);
2102 }
2103 if !self.data_type.is_empty() {
2104 ::buffa::encoding::Tag::new(
2105 2u32,
2106 ::buffa::encoding::WireType::LengthDelimited,
2107 )
2108 .encode(buf);
2109 ::buffa::types::encode_string(&self.data_type, buf);
2110 }
2111 if self.nullable {
2112 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
2113 .encode(buf);
2114 ::buffa::types::encode_bool(self.nullable, buf);
2115 }
2116 self.__buffa_unknown_fields.write_to(buf);
2117 }
2118 fn merge_field(
2119 &mut self,
2120 tag: ::buffa::encoding::Tag,
2121 buf: &mut impl ::buffa::bytes::Buf,
2122 depth: u32,
2123 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2124 #[allow(unused_imports)]
2125 use ::buffa::bytes::Buf as _;
2126 #[allow(unused_imports)]
2127 use ::buffa::Enumeration as _;
2128 match tag.field_number() {
2129 1u32 => {
2130 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2131 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2132 field_number: 1u32,
2133 expected: 2u8,
2134 actual: tag.wire_type() as u8,
2135 });
2136 }
2137 ::buffa::types::merge_string(&mut self.name, buf)?;
2138 }
2139 2u32 => {
2140 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2141 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2142 field_number: 2u32,
2143 expected: 2u8,
2144 actual: tag.wire_type() as u8,
2145 });
2146 }
2147 ::buffa::types::merge_string(&mut self.data_type, buf)?;
2148 }
2149 3u32 => {
2150 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2151 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2152 field_number: 3u32,
2153 expected: 0u8,
2154 actual: tag.wire_type() as u8,
2155 });
2156 }
2157 self.nullable = ::buffa::types::decode_bool(buf)?;
2158 }
2159 _ => {
2160 self.__buffa_unknown_fields
2161 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2162 }
2163 }
2164 ::core::result::Result::Ok(())
2165 }
2166 fn clear(&mut self) {
2167 self.name.clear();
2168 self.data_type.clear();
2169 self.nullable = false;
2170 self.__buffa_unknown_fields.clear();
2171 }
2172}
2173impl ::buffa::ExtensionSet for Column {
2174 const PROTO_FQN: &'static str = "sql.v1.Column";
2175 fn unknown_fields(&self) -> &::buffa::UnknownFields {
2176 &self.__buffa_unknown_fields
2177 }
2178 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
2179 &mut self.__buffa_unknown_fields
2180 }
2181}
2182impl ::buffa::json_helpers::ProtoElemJson for Column {
2183 fn serialize_proto_json<S: ::serde::Serializer>(
2184 v: &Self,
2185 s: S,
2186 ) -> ::core::result::Result<S::Ok, S::Error> {
2187 ::serde::Serialize::serialize(v, s)
2188 }
2189 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
2190 d: D,
2191 ) -> ::core::result::Result<Self, D::Error> {
2192 <Self as ::serde::Deserialize>::deserialize(d)
2193 }
2194}
2195#[doc(hidden)]
2196pub const __COLUMN_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
2197 type_url: "type.googleapis.com/sql.v1.Column",
2198 to_json: ::buffa::type_registry::any_to_json::<Column>,
2199 from_json: ::buffa::type_registry::any_from_json::<Column>,
2200 is_wkt: false,
2201};
2202#[derive(Clone, PartialEq, Default)]
2204#[derive(::serde::Serialize, ::serde::Deserialize)]
2205#[serde(default)]
2206pub struct Index {
2207 #[serde(
2209 rename = "name",
2210 with = "::buffa::json_helpers::proto_string",
2211 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2212 )]
2213 pub name: ::buffa::alloc::string::String,
2214 #[serde(
2216 rename = "layout",
2217 with = "::buffa::json_helpers::proto_enum",
2218 skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
2219 )]
2220 pub layout: ::buffa::EnumValue<IndexLayout>,
2221 #[serde(
2225 rename = "keyColumns",
2226 alias = "key_columns",
2227 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
2228 deserialize_with = "::buffa::json_helpers::null_as_default"
2229 )]
2230 pub key_columns: ::buffa::alloc::vec::Vec<u32>,
2231 #[serde(
2236 rename = "coverColumns",
2237 alias = "cover_columns",
2238 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
2239 deserialize_with = "::buffa::json_helpers::null_as_default"
2240 )]
2241 pub cover_columns: ::buffa::alloc::vec::Vec<u32>,
2242 #[serde(skip)]
2243 #[doc(hidden)]
2244 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2245}
2246impl ::core::fmt::Debug for Index {
2247 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2248 f.debug_struct("Index")
2249 .field("name", &self.name)
2250 .field("layout", &self.layout)
2251 .field("key_columns", &self.key_columns)
2252 .field("cover_columns", &self.cover_columns)
2253 .finish()
2254 }
2255}
2256impl Index {
2257 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Index";
2262}
2263impl ::buffa::DefaultInstance for Index {
2264 fn default_instance() -> &'static Self {
2265 static VALUE: ::buffa::__private::OnceBox<Index> = ::buffa::__private::OnceBox::new();
2266 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2267 }
2268}
2269impl ::buffa::MessageName for Index {
2270 const PACKAGE: &'static str = "sql.v1";
2271 const NAME: &'static str = "Index";
2272 const FULL_NAME: &'static str = "sql.v1.Index";
2273 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Index";
2274}
2275impl ::buffa::Message for Index {
2276 #[allow(clippy::let_and_return)]
2282 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
2283 #[allow(unused_imports)]
2284 use ::buffa::Enumeration as _;
2285 let mut size = 0u32;
2286 if !self.name.is_empty() {
2287 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
2288 }
2289 {
2290 let val = self.layout.to_i32();
2291 if val != 0 {
2292 size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
2293 }
2294 }
2295 if !self.key_columns.is_empty() {
2296 let payload: u32 = self
2297 .key_columns
2298 .iter()
2299 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
2300 .sum::<u32>();
2301 size
2302 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
2303 }
2304 if !self.cover_columns.is_empty() {
2305 let payload: u32 = self
2306 .cover_columns
2307 .iter()
2308 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
2309 .sum::<u32>();
2310 size
2311 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
2312 }
2313 size += self.__buffa_unknown_fields.encoded_len() as u32;
2314 size
2315 }
2316 fn write_to(
2317 &self,
2318 _cache: &mut ::buffa::SizeCache,
2319 buf: &mut impl ::buffa::bytes::BufMut,
2320 ) {
2321 #[allow(unused_imports)]
2322 use ::buffa::Enumeration as _;
2323 if !self.name.is_empty() {
2324 ::buffa::encoding::Tag::new(
2325 1u32,
2326 ::buffa::encoding::WireType::LengthDelimited,
2327 )
2328 .encode(buf);
2329 ::buffa::types::encode_string(&self.name, buf);
2330 }
2331 {
2332 let val = self.layout.to_i32();
2333 if val != 0 {
2334 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
2335 .encode(buf);
2336 ::buffa::types::encode_int32(val, buf);
2337 }
2338 }
2339 if !self.key_columns.is_empty() {
2340 let payload: u32 = self
2341 .key_columns
2342 .iter()
2343 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
2344 .sum::<u32>();
2345 ::buffa::encoding::Tag::new(
2346 3u32,
2347 ::buffa::encoding::WireType::LengthDelimited,
2348 )
2349 .encode(buf);
2350 ::buffa::encoding::encode_varint(payload as u64, buf);
2351 for &v in &self.key_columns {
2352 ::buffa::types::encode_uint32(v, buf);
2353 }
2354 }
2355 if !self.cover_columns.is_empty() {
2356 let payload: u32 = self
2357 .cover_columns
2358 .iter()
2359 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
2360 .sum::<u32>();
2361 ::buffa::encoding::Tag::new(
2362 4u32,
2363 ::buffa::encoding::WireType::LengthDelimited,
2364 )
2365 .encode(buf);
2366 ::buffa::encoding::encode_varint(payload as u64, buf);
2367 for &v in &self.cover_columns {
2368 ::buffa::types::encode_uint32(v, buf);
2369 }
2370 }
2371 self.__buffa_unknown_fields.write_to(buf);
2372 }
2373 fn merge_field(
2374 &mut self,
2375 tag: ::buffa::encoding::Tag,
2376 buf: &mut impl ::buffa::bytes::Buf,
2377 depth: u32,
2378 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2379 #[allow(unused_imports)]
2380 use ::buffa::bytes::Buf as _;
2381 #[allow(unused_imports)]
2382 use ::buffa::Enumeration as _;
2383 match tag.field_number() {
2384 1u32 => {
2385 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2386 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2387 field_number: 1u32,
2388 expected: 2u8,
2389 actual: tag.wire_type() as u8,
2390 });
2391 }
2392 ::buffa::types::merge_string(&mut self.name, buf)?;
2393 }
2394 2u32 => {
2395 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2396 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2397 field_number: 2u32,
2398 expected: 0u8,
2399 actual: tag.wire_type() as u8,
2400 });
2401 }
2402 self.layout = ::buffa::EnumValue::from(
2403 ::buffa::types::decode_int32(buf)?,
2404 );
2405 }
2406 3u32 => {
2407 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
2408 let len = ::buffa::encoding::decode_varint(buf)?;
2409 let len = usize::try_from(len)
2410 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
2411 if buf.remaining() < len {
2412 return ::core::result::Result::Err(
2413 ::buffa::DecodeError::UnexpectedEof,
2414 );
2415 }
2416 self.key_columns.reserve(len);
2417 let mut limited = buf.take(len);
2418 while limited.has_remaining() {
2419 self.key_columns
2420 .push(::buffa::types::decode_uint32(&mut limited)?);
2421 }
2422 let leftover = limited.remaining();
2423 if leftover > 0 {
2424 limited.advance(leftover);
2425 }
2426 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
2427 self.key_columns.push(::buffa::types::decode_uint32(buf)?);
2428 } else {
2429 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2430 field_number: 3u32,
2431 expected: 2u8,
2432 actual: tag.wire_type() as u8,
2433 });
2434 }
2435 }
2436 4u32 => {
2437 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
2438 let len = ::buffa::encoding::decode_varint(buf)?;
2439 let len = usize::try_from(len)
2440 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
2441 if buf.remaining() < len {
2442 return ::core::result::Result::Err(
2443 ::buffa::DecodeError::UnexpectedEof,
2444 );
2445 }
2446 self.cover_columns.reserve(len);
2447 let mut limited = buf.take(len);
2448 while limited.has_remaining() {
2449 self.cover_columns
2450 .push(::buffa::types::decode_uint32(&mut limited)?);
2451 }
2452 let leftover = limited.remaining();
2453 if leftover > 0 {
2454 limited.advance(leftover);
2455 }
2456 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
2457 self.cover_columns.push(::buffa::types::decode_uint32(buf)?);
2458 } else {
2459 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2460 field_number: 4u32,
2461 expected: 2u8,
2462 actual: tag.wire_type() as u8,
2463 });
2464 }
2465 }
2466 _ => {
2467 self.__buffa_unknown_fields
2468 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2469 }
2470 }
2471 ::core::result::Result::Ok(())
2472 }
2473 fn clear(&mut self) {
2474 self.name.clear();
2475 self.layout = ::buffa::EnumValue::from(0);
2476 self.key_columns.clear();
2477 self.cover_columns.clear();
2478 self.__buffa_unknown_fields.clear();
2479 }
2480}
2481impl ::buffa::ExtensionSet for Index {
2482 const PROTO_FQN: &'static str = "sql.v1.Index";
2483 fn unknown_fields(&self) -> &::buffa::UnknownFields {
2484 &self.__buffa_unknown_fields
2485 }
2486 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
2487 &mut self.__buffa_unknown_fields
2488 }
2489}
2490impl ::buffa::json_helpers::ProtoElemJson for Index {
2491 fn serialize_proto_json<S: ::serde::Serializer>(
2492 v: &Self,
2493 s: S,
2494 ) -> ::core::result::Result<S::Ok, S::Error> {
2495 ::serde::Serialize::serialize(v, s)
2496 }
2497 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
2498 d: D,
2499 ) -> ::core::result::Result<Self, D::Error> {
2500 <Self as ::serde::Deserialize>::deserialize(d)
2501 }
2502}
2503#[doc(hidden)]
2504pub const __INDEX_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
2505 type_url: "type.googleapis.com/sql.v1.Index",
2506 to_json: ::buffa::type_registry::any_to_json::<Index>,
2507 from_json: ::buffa::type_registry::any_from_json::<Index>,
2508 is_wkt: false,
2509};
2510#[derive(Clone, PartialEq, Default)]
2512#[derive(::serde::Serialize, ::serde::Deserialize)]
2513#[serde(default)]
2514pub struct QueryRequest {
2515 #[serde(
2517 rename = "sql",
2518 with = "::buffa::json_helpers::proto_string",
2519 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2520 )]
2521 pub sql: ::buffa::alloc::string::String,
2522 #[serde(skip)]
2523 #[doc(hidden)]
2524 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2525}
2526impl ::core::fmt::Debug for QueryRequest {
2527 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2528 f.debug_struct("QueryRequest").field("sql", &self.sql).finish()
2529 }
2530}
2531impl QueryRequest {
2532 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryRequest";
2537}
2538impl ::buffa::DefaultInstance for QueryRequest {
2539 fn default_instance() -> &'static Self {
2540 static VALUE: ::buffa::__private::OnceBox<QueryRequest> = ::buffa::__private::OnceBox::new();
2541 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2542 }
2543}
2544impl ::buffa::MessageName for QueryRequest {
2545 const PACKAGE: &'static str = "sql.v1";
2546 const NAME: &'static str = "QueryRequest";
2547 const FULL_NAME: &'static str = "sql.v1.QueryRequest";
2548 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryRequest";
2549}
2550impl ::buffa::Message for QueryRequest {
2551 #[allow(clippy::let_and_return)]
2557 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
2558 #[allow(unused_imports)]
2559 use ::buffa::Enumeration as _;
2560 let mut size = 0u32;
2561 if !self.sql.is_empty() {
2562 size += 1u32 + ::buffa::types::string_encoded_len(&self.sql) as u32;
2563 }
2564 size += self.__buffa_unknown_fields.encoded_len() as u32;
2565 size
2566 }
2567 fn write_to(
2568 &self,
2569 _cache: &mut ::buffa::SizeCache,
2570 buf: &mut impl ::buffa::bytes::BufMut,
2571 ) {
2572 #[allow(unused_imports)]
2573 use ::buffa::Enumeration as _;
2574 if !self.sql.is_empty() {
2575 ::buffa::encoding::Tag::new(
2576 1u32,
2577 ::buffa::encoding::WireType::LengthDelimited,
2578 )
2579 .encode(buf);
2580 ::buffa::types::encode_string(&self.sql, buf);
2581 }
2582 self.__buffa_unknown_fields.write_to(buf);
2583 }
2584 fn merge_field(
2585 &mut self,
2586 tag: ::buffa::encoding::Tag,
2587 buf: &mut impl ::buffa::bytes::Buf,
2588 depth: u32,
2589 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2590 #[allow(unused_imports)]
2591 use ::buffa::bytes::Buf as _;
2592 #[allow(unused_imports)]
2593 use ::buffa::Enumeration as _;
2594 match tag.field_number() {
2595 1u32 => {
2596 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2597 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2598 field_number: 1u32,
2599 expected: 2u8,
2600 actual: tag.wire_type() as u8,
2601 });
2602 }
2603 ::buffa::types::merge_string(&mut self.sql, buf)?;
2604 }
2605 _ => {
2606 self.__buffa_unknown_fields
2607 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2608 }
2609 }
2610 ::core::result::Result::Ok(())
2611 }
2612 fn clear(&mut self) {
2613 self.sql.clear();
2614 self.__buffa_unknown_fields.clear();
2615 }
2616}
2617impl ::buffa::ExtensionSet for QueryRequest {
2618 const PROTO_FQN: &'static str = "sql.v1.QueryRequest";
2619 fn unknown_fields(&self) -> &::buffa::UnknownFields {
2620 &self.__buffa_unknown_fields
2621 }
2622 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
2623 &mut self.__buffa_unknown_fields
2624 }
2625}
2626impl ::buffa::json_helpers::ProtoElemJson for QueryRequest {
2627 fn serialize_proto_json<S: ::serde::Serializer>(
2628 v: &Self,
2629 s: S,
2630 ) -> ::core::result::Result<S::Ok, S::Error> {
2631 ::serde::Serialize::serialize(v, s)
2632 }
2633 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
2634 d: D,
2635 ) -> ::core::result::Result<Self, D::Error> {
2636 <Self as ::serde::Deserialize>::deserialize(d)
2637 }
2638}
2639#[doc(hidden)]
2640pub const __QUERY_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
2641 type_url: "type.googleapis.com/sql.v1.QueryRequest",
2642 to_json: ::buffa::type_registry::any_to_json::<QueryRequest>,
2643 from_json: ::buffa::type_registry::any_from_json::<QueryRequest>,
2644 is_wkt: false,
2645};
2646#[derive(Clone, PartialEq, Default)]
2648#[derive(::serde::Serialize, ::serde::Deserialize)]
2649#[serde(default)]
2650pub struct QueryResponse {
2651 #[serde(
2653 rename = "column",
2654 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
2655 deserialize_with = "::buffa::json_helpers::null_as_default"
2656 )]
2657 pub column: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
2658 #[serde(
2660 rename = "rows",
2661 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
2662 deserialize_with = "::buffa::json_helpers::null_as_default"
2663 )]
2664 pub rows: ::buffa::alloc::vec::Vec<Row>,
2665 #[serde(skip)]
2666 #[doc(hidden)]
2667 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2668}
2669impl ::core::fmt::Debug for QueryResponse {
2670 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2671 f.debug_struct("QueryResponse")
2672 .field("column", &self.column)
2673 .field("rows", &self.rows)
2674 .finish()
2675 }
2676}
2677impl QueryResponse {
2678 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryResponse";
2683}
2684impl ::buffa::DefaultInstance for QueryResponse {
2685 fn default_instance() -> &'static Self {
2686 static VALUE: ::buffa::__private::OnceBox<QueryResponse> = ::buffa::__private::OnceBox::new();
2687 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2688 }
2689}
2690impl ::buffa::MessageName for QueryResponse {
2691 const PACKAGE: &'static str = "sql.v1";
2692 const NAME: &'static str = "QueryResponse";
2693 const FULL_NAME: &'static str = "sql.v1.QueryResponse";
2694 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryResponse";
2695}
2696impl ::buffa::Message for QueryResponse {
2697 #[allow(clippy::let_and_return)]
2703 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
2704 #[allow(unused_imports)]
2705 use ::buffa::Enumeration as _;
2706 let mut size = 0u32;
2707 for v in &self.column {
2708 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
2709 }
2710 for v in &self.rows {
2711 let __slot = __cache.reserve();
2712 let inner_size = v.compute_size(__cache);
2713 __cache.set(__slot, inner_size);
2714 size
2715 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
2716 + inner_size;
2717 }
2718 size += self.__buffa_unknown_fields.encoded_len() as u32;
2719 size
2720 }
2721 fn write_to(
2722 &self,
2723 __cache: &mut ::buffa::SizeCache,
2724 buf: &mut impl ::buffa::bytes::BufMut,
2725 ) {
2726 #[allow(unused_imports)]
2727 use ::buffa::Enumeration as _;
2728 for v in &self.column {
2729 ::buffa::encoding::Tag::new(
2730 1u32,
2731 ::buffa::encoding::WireType::LengthDelimited,
2732 )
2733 .encode(buf);
2734 ::buffa::types::encode_string(v, buf);
2735 }
2736 for v in &self.rows {
2737 ::buffa::encoding::Tag::new(
2738 2u32,
2739 ::buffa::encoding::WireType::LengthDelimited,
2740 )
2741 .encode(buf);
2742 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
2743 v.write_to(__cache, buf);
2744 }
2745 self.__buffa_unknown_fields.write_to(buf);
2746 }
2747 fn merge_field(
2748 &mut self,
2749 tag: ::buffa::encoding::Tag,
2750 buf: &mut impl ::buffa::bytes::Buf,
2751 depth: u32,
2752 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2753 #[allow(unused_imports)]
2754 use ::buffa::bytes::Buf as _;
2755 #[allow(unused_imports)]
2756 use ::buffa::Enumeration as _;
2757 match tag.field_number() {
2758 1u32 => {
2759 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2760 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2761 field_number: 1u32,
2762 expected: 2u8,
2763 actual: tag.wire_type() as u8,
2764 });
2765 }
2766 self.column.push(::buffa::types::decode_string(buf)?);
2767 }
2768 2u32 => {
2769 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2770 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2771 field_number: 2u32,
2772 expected: 2u8,
2773 actual: tag.wire_type() as u8,
2774 });
2775 }
2776 let mut elem = ::core::default::Default::default();
2777 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
2778 self.rows.push(elem);
2779 }
2780 _ => {
2781 self.__buffa_unknown_fields
2782 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2783 }
2784 }
2785 ::core::result::Result::Ok(())
2786 }
2787 fn clear(&mut self) {
2788 self.column.clear();
2789 self.rows.clear();
2790 self.__buffa_unknown_fields.clear();
2791 }
2792}
2793impl ::buffa::ExtensionSet for QueryResponse {
2794 const PROTO_FQN: &'static str = "sql.v1.QueryResponse";
2795 fn unknown_fields(&self) -> &::buffa::UnknownFields {
2796 &self.__buffa_unknown_fields
2797 }
2798 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
2799 &mut self.__buffa_unknown_fields
2800 }
2801}
2802impl ::buffa::json_helpers::ProtoElemJson for QueryResponse {
2803 fn serialize_proto_json<S: ::serde::Serializer>(
2804 v: &Self,
2805 s: S,
2806 ) -> ::core::result::Result<S::Ok, S::Error> {
2807 ::serde::Serialize::serialize(v, s)
2808 }
2809 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
2810 d: D,
2811 ) -> ::core::result::Result<Self, D::Error> {
2812 <Self as ::serde::Deserialize>::deserialize(d)
2813 }
2814}
2815#[doc(hidden)]
2816pub const __QUERY_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
2817 type_url: "type.googleapis.com/sql.v1.QueryResponse",
2818 to_json: ::buffa::type_registry::any_to_json::<QueryResponse>,
2819 from_json: ::buffa::type_registry::any_from_json::<QueryResponse>,
2820 is_wkt: false,
2821};
2822#[derive(Clone, PartialEq, Default)]
2824#[derive(::serde::Serialize, ::serde::Deserialize)]
2825#[serde(default)]
2826pub struct SubscribeRequest {
2827 #[serde(
2831 rename = "table",
2832 with = "::buffa::json_helpers::proto_string",
2833 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2834 )]
2835 pub table: ::buffa::alloc::string::String,
2836 #[serde(
2842 rename = "whereSql",
2843 alias = "where_sql",
2844 with = "::buffa::json_helpers::proto_string",
2845 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2846 )]
2847 pub where_sql: ::buffa::alloc::string::String,
2848 #[serde(
2853 rename = "sinceSequenceNumber",
2854 alias = "since_sequence_number",
2855 with = "::buffa::json_helpers::opt_uint64",
2856 skip_serializing_if = "::core::option::Option::is_none"
2857 )]
2858 pub since_sequence_number: ::core::option::Option<u64>,
2859 #[serde(skip)]
2860 #[doc(hidden)]
2861 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2862}
2863impl ::core::fmt::Debug for SubscribeRequest {
2864 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2865 f.debug_struct("SubscribeRequest")
2866 .field("table", &self.table)
2867 .field("where_sql", &self.where_sql)
2868 .field("since_sequence_number", &self.since_sequence_number)
2869 .finish()
2870 }
2871}
2872impl SubscribeRequest {
2873 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeRequest";
2878}
2879impl SubscribeRequest {
2880 #[must_use = "with_* setters return `self` by value; assign or chain the result"]
2881 #[inline]
2882 pub fn with_since_sequence_number(mut self, value: u64) -> Self {
2884 self.since_sequence_number = Some(value);
2885 self
2886 }
2887}
2888impl ::buffa::DefaultInstance for SubscribeRequest {
2889 fn default_instance() -> &'static Self {
2890 static VALUE: ::buffa::__private::OnceBox<SubscribeRequest> = ::buffa::__private::OnceBox::new();
2891 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2892 }
2893}
2894impl ::buffa::MessageName for SubscribeRequest {
2895 const PACKAGE: &'static str = "sql.v1";
2896 const NAME: &'static str = "SubscribeRequest";
2897 const FULL_NAME: &'static str = "sql.v1.SubscribeRequest";
2898 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeRequest";
2899}
2900impl ::buffa::Message for SubscribeRequest {
2901 #[allow(clippy::let_and_return)]
2907 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
2908 #[allow(unused_imports)]
2909 use ::buffa::Enumeration as _;
2910 let mut size = 0u32;
2911 if !self.table.is_empty() {
2912 size += 1u32 + ::buffa::types::string_encoded_len(&self.table) as u32;
2913 }
2914 if !self.where_sql.is_empty() {
2915 size += 1u32 + ::buffa::types::string_encoded_len(&self.where_sql) as u32;
2916 }
2917 if let Some(v) = self.since_sequence_number {
2918 size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
2919 }
2920 size += self.__buffa_unknown_fields.encoded_len() as u32;
2921 size
2922 }
2923 fn write_to(
2924 &self,
2925 _cache: &mut ::buffa::SizeCache,
2926 buf: &mut impl ::buffa::bytes::BufMut,
2927 ) {
2928 #[allow(unused_imports)]
2929 use ::buffa::Enumeration as _;
2930 if !self.table.is_empty() {
2931 ::buffa::encoding::Tag::new(
2932 1u32,
2933 ::buffa::encoding::WireType::LengthDelimited,
2934 )
2935 .encode(buf);
2936 ::buffa::types::encode_string(&self.table, buf);
2937 }
2938 if !self.where_sql.is_empty() {
2939 ::buffa::encoding::Tag::new(
2940 2u32,
2941 ::buffa::encoding::WireType::LengthDelimited,
2942 )
2943 .encode(buf);
2944 ::buffa::types::encode_string(&self.where_sql, buf);
2945 }
2946 if let Some(v) = self.since_sequence_number {
2947 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
2948 .encode(buf);
2949 ::buffa::types::encode_uint64(v, buf);
2950 }
2951 self.__buffa_unknown_fields.write_to(buf);
2952 }
2953 fn merge_field(
2954 &mut self,
2955 tag: ::buffa::encoding::Tag,
2956 buf: &mut impl ::buffa::bytes::Buf,
2957 depth: u32,
2958 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2959 #[allow(unused_imports)]
2960 use ::buffa::bytes::Buf as _;
2961 #[allow(unused_imports)]
2962 use ::buffa::Enumeration as _;
2963 match tag.field_number() {
2964 1u32 => {
2965 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2966 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2967 field_number: 1u32,
2968 expected: 2u8,
2969 actual: tag.wire_type() as u8,
2970 });
2971 }
2972 ::buffa::types::merge_string(&mut self.table, buf)?;
2973 }
2974 2u32 => {
2975 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2976 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2977 field_number: 2u32,
2978 expected: 2u8,
2979 actual: tag.wire_type() as u8,
2980 });
2981 }
2982 ::buffa::types::merge_string(&mut self.where_sql, buf)?;
2983 }
2984 3u32 => {
2985 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2986 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2987 field_number: 3u32,
2988 expected: 0u8,
2989 actual: tag.wire_type() as u8,
2990 });
2991 }
2992 self.since_sequence_number = ::core::option::Option::Some(
2993 ::buffa::types::decode_uint64(buf)?,
2994 );
2995 }
2996 _ => {
2997 self.__buffa_unknown_fields
2998 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2999 }
3000 }
3001 ::core::result::Result::Ok(())
3002 }
3003 fn clear(&mut self) {
3004 self.table.clear();
3005 self.where_sql.clear();
3006 self.since_sequence_number = ::core::option::Option::None;
3007 self.__buffa_unknown_fields.clear();
3008 }
3009}
3010impl ::buffa::ExtensionSet for SubscribeRequest {
3011 const PROTO_FQN: &'static str = "sql.v1.SubscribeRequest";
3012 fn unknown_fields(&self) -> &::buffa::UnknownFields {
3013 &self.__buffa_unknown_fields
3014 }
3015 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
3016 &mut self.__buffa_unknown_fields
3017 }
3018}
3019impl ::buffa::json_helpers::ProtoElemJson for SubscribeRequest {
3020 fn serialize_proto_json<S: ::serde::Serializer>(
3021 v: &Self,
3022 s: S,
3023 ) -> ::core::result::Result<S::Ok, S::Error> {
3024 ::serde::Serialize::serialize(v, s)
3025 }
3026 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
3027 d: D,
3028 ) -> ::core::result::Result<Self, D::Error> {
3029 <Self as ::serde::Deserialize>::deserialize(d)
3030 }
3031}
3032#[doc(hidden)]
3033pub const __SUBSCRIBE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
3034 type_url: "type.googleapis.com/sql.v1.SubscribeRequest",
3035 to_json: ::buffa::type_registry::any_to_json::<SubscribeRequest>,
3036 from_json: ::buffa::type_registry::any_from_json::<SubscribeRequest>,
3037 is_wkt: false,
3038};
3039#[derive(Clone, PartialEq, Default)]
3041#[derive(::serde::Serialize, ::serde::Deserialize)]
3042#[serde(default)]
3043pub struct SubscribeResponse {
3044 #[serde(
3049 rename = "sequenceNumber",
3050 alias = "sequence_number",
3051 with = "::buffa::json_helpers::uint64",
3052 skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
3053 )]
3054 pub sequence_number: u64,
3055 #[serde(
3059 rename = "column",
3060 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
3061 deserialize_with = "::buffa::json_helpers::null_as_default"
3062 )]
3063 pub column: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
3064 #[serde(
3069 rename = "rows",
3070 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
3071 deserialize_with = "::buffa::json_helpers::null_as_default"
3072 )]
3073 pub rows: ::buffa::alloc::vec::Vec<Row>,
3074 #[serde(skip)]
3075 #[doc(hidden)]
3076 pub __buffa_unknown_fields: ::buffa::UnknownFields,
3077}
3078impl ::core::fmt::Debug for SubscribeResponse {
3079 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3080 f.debug_struct("SubscribeResponse")
3081 .field("sequence_number", &self.sequence_number)
3082 .field("column", &self.column)
3083 .field("rows", &self.rows)
3084 .finish()
3085 }
3086}
3087impl SubscribeResponse {
3088 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeResponse";
3093}
3094impl ::buffa::DefaultInstance for SubscribeResponse {
3095 fn default_instance() -> &'static Self {
3096 static VALUE: ::buffa::__private::OnceBox<SubscribeResponse> = ::buffa::__private::OnceBox::new();
3097 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
3098 }
3099}
3100impl ::buffa::MessageName for SubscribeResponse {
3101 const PACKAGE: &'static str = "sql.v1";
3102 const NAME: &'static str = "SubscribeResponse";
3103 const FULL_NAME: &'static str = "sql.v1.SubscribeResponse";
3104 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeResponse";
3105}
3106impl ::buffa::Message for SubscribeResponse {
3107 #[allow(clippy::let_and_return)]
3113 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
3114 #[allow(unused_imports)]
3115 use ::buffa::Enumeration as _;
3116 let mut size = 0u32;
3117 if self.sequence_number != 0u64 {
3118 size
3119 += 1u32
3120 + ::buffa::types::uint64_encoded_len(self.sequence_number) as u32;
3121 }
3122 for v in &self.column {
3123 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
3124 }
3125 for v in &self.rows {
3126 let __slot = __cache.reserve();
3127 let inner_size = v.compute_size(__cache);
3128 __cache.set(__slot, inner_size);
3129 size
3130 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3131 + inner_size;
3132 }
3133 size += self.__buffa_unknown_fields.encoded_len() as u32;
3134 size
3135 }
3136 fn write_to(
3137 &self,
3138 __cache: &mut ::buffa::SizeCache,
3139 buf: &mut impl ::buffa::bytes::BufMut,
3140 ) {
3141 #[allow(unused_imports)]
3142 use ::buffa::Enumeration as _;
3143 if self.sequence_number != 0u64 {
3144 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
3145 .encode(buf);
3146 ::buffa::types::encode_uint64(self.sequence_number, buf);
3147 }
3148 for v in &self.column {
3149 ::buffa::encoding::Tag::new(
3150 2u32,
3151 ::buffa::encoding::WireType::LengthDelimited,
3152 )
3153 .encode(buf);
3154 ::buffa::types::encode_string(v, buf);
3155 }
3156 for v in &self.rows {
3157 ::buffa::encoding::Tag::new(
3158 3u32,
3159 ::buffa::encoding::WireType::LengthDelimited,
3160 )
3161 .encode(buf);
3162 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
3163 v.write_to(__cache, buf);
3164 }
3165 self.__buffa_unknown_fields.write_to(buf);
3166 }
3167 fn merge_field(
3168 &mut self,
3169 tag: ::buffa::encoding::Tag,
3170 buf: &mut impl ::buffa::bytes::Buf,
3171 depth: u32,
3172 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3173 #[allow(unused_imports)]
3174 use ::buffa::bytes::Buf as _;
3175 #[allow(unused_imports)]
3176 use ::buffa::Enumeration as _;
3177 match tag.field_number() {
3178 1u32 => {
3179 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3180 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3181 field_number: 1u32,
3182 expected: 0u8,
3183 actual: tag.wire_type() as u8,
3184 });
3185 }
3186 self.sequence_number = ::buffa::types::decode_uint64(buf)?;
3187 }
3188 2u32 => {
3189 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3190 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3191 field_number: 2u32,
3192 expected: 2u8,
3193 actual: tag.wire_type() as u8,
3194 });
3195 }
3196 self.column.push(::buffa::types::decode_string(buf)?);
3197 }
3198 3u32 => {
3199 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3200 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3201 field_number: 3u32,
3202 expected: 2u8,
3203 actual: tag.wire_type() as u8,
3204 });
3205 }
3206 let mut elem = ::core::default::Default::default();
3207 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
3208 self.rows.push(elem);
3209 }
3210 _ => {
3211 self.__buffa_unknown_fields
3212 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
3213 }
3214 }
3215 ::core::result::Result::Ok(())
3216 }
3217 fn clear(&mut self) {
3218 self.sequence_number = 0u64;
3219 self.column.clear();
3220 self.rows.clear();
3221 self.__buffa_unknown_fields.clear();
3222 }
3223}
3224impl ::buffa::ExtensionSet for SubscribeResponse {
3225 const PROTO_FQN: &'static str = "sql.v1.SubscribeResponse";
3226 fn unknown_fields(&self) -> &::buffa::UnknownFields {
3227 &self.__buffa_unknown_fields
3228 }
3229 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
3230 &mut self.__buffa_unknown_fields
3231 }
3232}
3233impl ::buffa::json_helpers::ProtoElemJson for SubscribeResponse {
3234 fn serialize_proto_json<S: ::serde::Serializer>(
3235 v: &Self,
3236 s: S,
3237 ) -> ::core::result::Result<S::Ok, S::Error> {
3238 ::serde::Serialize::serialize(v, s)
3239 }
3240 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
3241 d: D,
3242 ) -> ::core::result::Result<Self, D::Error> {
3243 <Self as ::serde::Deserialize>::deserialize(d)
3244 }
3245}
3246#[doc(hidden)]
3247pub const __SUBSCRIBE_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
3248 type_url: "type.googleapis.com/sql.v1.SubscribeResponse",
3249 to_json: ::buffa::type_registry::any_to_json::<SubscribeResponse>,
3250 from_json: ::buffa::type_registry::any_from_json::<SubscribeResponse>,
3251 is_wkt: false,
3252};
3253#[allow(
3254 non_camel_case_types,
3255 dead_code,
3256 unused_imports,
3257 unused_qualifications,
3258 clippy::derivable_impls,
3259 clippy::match_single_binding,
3260 clippy::uninlined_format_args,
3261 clippy::doc_lazy_continuation,
3262 clippy::module_inception
3263)]
3264pub mod __buffa {
3265 #[allow(unused_imports)]
3266 use super::*;
3267 pub mod view {
3268 #[allow(unused_imports)]
3269 use super::*;
3270 #[derive(Clone, Debug, Default)]
3272 pub struct RowView<'a> {
3273 pub cells: ::buffa::RepeatedView<
3275 'a,
3276 super::super::__buffa::view::CellView<'a>,
3277 >,
3278 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3279 }
3280 impl<'a> RowView<'a> {
3281 #[doc(hidden)]
3289 pub fn _decode_depth(
3290 buf: &'a [u8],
3291 depth: u32,
3292 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3293 let mut view = Self::default();
3294 view._merge_into_view(buf, depth)?;
3295 ::core::result::Result::Ok(view)
3296 }
3297 #[doc(hidden)]
3305 pub fn _merge_into_view(
3306 &mut self,
3307 buf: &'a [u8],
3308 depth: u32,
3309 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3310 let _ = depth;
3311 #[allow(unused_variables)]
3312 let view = self;
3313 let mut cur: &'a [u8] = buf;
3314 while !cur.is_empty() {
3315 let before_tag = cur;
3316 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
3317 match tag.field_number() {
3318 1u32 => {
3319 if tag.wire_type()
3320 != ::buffa::encoding::WireType::LengthDelimited
3321 {
3322 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3323 field_number: 1u32,
3324 expected: 2u8,
3325 actual: tag.wire_type() as u8,
3326 });
3327 }
3328 if depth == 0 {
3329 return Err(::buffa::DecodeError::RecursionLimitExceeded);
3330 }
3331 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3332 view.cells
3333 .push(
3334 super::super::__buffa::view::CellView::_decode_depth(
3335 sub,
3336 depth - 1,
3337 )?,
3338 );
3339 }
3340 _ => {
3341 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
3342 let span_len = before_tag.len() - cur.len();
3343 view.__buffa_unknown_fields
3344 .push_raw(&before_tag[..span_len]);
3345 }
3346 }
3347 }
3348 ::core::result::Result::Ok(())
3349 }
3350 }
3351 impl<'a> ::buffa::MessageView<'a> for RowView<'a> {
3352 type Owned = super::super::Row;
3353 fn decode_view(
3354 buf: &'a [u8],
3355 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3356 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
3357 }
3358 fn decode_view_with_limit(
3359 buf: &'a [u8],
3360 depth: u32,
3361 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3362 Self::_decode_depth(buf, depth)
3363 }
3364 fn to_owned_message(&self) -> super::super::Row {
3365 self.to_owned_from_source(None)
3366 }
3367 #[allow(clippy::useless_conversion, clippy::needless_update)]
3368 fn to_owned_from_source(
3369 &self,
3370 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
3371 ) -> super::super::Row {
3372 #[allow(unused_imports)]
3373 use ::buffa::alloc::string::ToString as _;
3374 let _ = __buffa_src;
3375 super::super::Row {
3376 cells: self
3377 .cells
3378 .iter()
3379 .map(|v| v.to_owned_from_source(__buffa_src))
3380 .collect(),
3381 __buffa_unknown_fields: self
3382 .__buffa_unknown_fields
3383 .to_owned()
3384 .unwrap_or_default()
3385 .into(),
3386 ..::core::default::Default::default()
3387 }
3388 }
3389 }
3390 impl<'a> ::buffa::ViewEncode<'a> for RowView<'a> {
3391 #[allow(clippy::needless_borrow, clippy::let_and_return)]
3392 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
3393 #[allow(unused_imports)]
3394 use ::buffa::Enumeration as _;
3395 let mut size = 0u32;
3396 for v in &self.cells {
3397 let __slot = __cache.reserve();
3398 let inner_size = v.compute_size(__cache);
3399 __cache.set(__slot, inner_size);
3400 size
3401 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3402 + inner_size;
3403 }
3404 size += self.__buffa_unknown_fields.encoded_len() as u32;
3405 size
3406 }
3407 #[allow(clippy::needless_borrow)]
3408 fn write_to(
3409 &self,
3410 __cache: &mut ::buffa::SizeCache,
3411 buf: &mut impl ::buffa::bytes::BufMut,
3412 ) {
3413 #[allow(unused_imports)]
3414 use ::buffa::Enumeration as _;
3415 for v in &self.cells {
3416 ::buffa::encoding::Tag::new(
3417 1u32,
3418 ::buffa::encoding::WireType::LengthDelimited,
3419 )
3420 .encode(buf);
3421 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
3422 v.write_to(__cache, buf);
3423 }
3424 self.__buffa_unknown_fields.write_to(buf);
3425 }
3426 }
3427 impl<'__a> ::serde::Serialize for RowView<'__a> {
3439 fn serialize<__S: ::serde::Serializer>(
3440 &self,
3441 __s: __S,
3442 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3443 use ::serde::ser::SerializeMap as _;
3444 let mut __map = __s.serialize_map(::core::option::Option::None)?;
3445 if !self.cells.is_empty() {
3446 __map.serialize_entry("cells", &*self.cells)?;
3447 }
3448 __map.end()
3449 }
3450 }
3451 impl<'a> ::buffa::MessageName for RowView<'a> {
3452 const PACKAGE: &'static str = "sql.v1";
3453 const NAME: &'static str = "Row";
3454 const FULL_NAME: &'static str = "sql.v1.Row";
3455 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Row";
3456 }
3457 impl<'v> ::buffa::DefaultViewInstance for RowView<'v> {
3458 fn default_view_instance<'a>() -> &'a Self
3459 where
3460 Self: 'a,
3461 {
3462 static VALUE: ::buffa::__private::OnceBox<RowView<'static>> = ::buffa::__private::OnceBox::new();
3463 VALUE
3464 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
3465 <RowView<'static>>::default(),
3466 ))
3467 }
3468 }
3469 impl ::buffa::ViewReborrow for RowView<'static> {
3470 type Reborrowed<'b> = RowView<'b>;
3471 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
3472 this
3473 }
3474 }
3475 #[derive(Clone, Debug, Default)]
3478 pub struct NullView<'a> {
3479 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3480 }
3481 impl<'a> NullView<'a> {
3482 #[doc(hidden)]
3490 pub fn _decode_depth(
3491 buf: &'a [u8],
3492 depth: u32,
3493 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3494 let mut view = Self::default();
3495 view._merge_into_view(buf, depth)?;
3496 ::core::result::Result::Ok(view)
3497 }
3498 #[doc(hidden)]
3506 pub fn _merge_into_view(
3507 &mut self,
3508 buf: &'a [u8],
3509 depth: u32,
3510 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3511 let _ = depth;
3512 #[allow(unused_variables)]
3513 let view = self;
3514 let mut cur: &'a [u8] = buf;
3515 while !cur.is_empty() {
3516 let before_tag = cur;
3517 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
3518 match tag.field_number() {
3519 _ => {
3520 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
3521 let span_len = before_tag.len() - cur.len();
3522 view.__buffa_unknown_fields
3523 .push_raw(&before_tag[..span_len]);
3524 }
3525 }
3526 }
3527 ::core::result::Result::Ok(())
3528 }
3529 }
3530 impl<'a> ::buffa::MessageView<'a> for NullView<'a> {
3531 type Owned = super::super::Null;
3532 fn decode_view(
3533 buf: &'a [u8],
3534 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3535 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
3536 }
3537 fn decode_view_with_limit(
3538 buf: &'a [u8],
3539 depth: u32,
3540 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3541 Self::_decode_depth(buf, depth)
3542 }
3543 fn to_owned_message(&self) -> super::super::Null {
3544 self.to_owned_from_source(None)
3545 }
3546 #[allow(clippy::useless_conversion, clippy::needless_update)]
3547 fn to_owned_from_source(
3548 &self,
3549 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
3550 ) -> super::super::Null {
3551 #[allow(unused_imports)]
3552 use ::buffa::alloc::string::ToString as _;
3553 let _ = __buffa_src;
3554 super::super::Null {
3555 __buffa_unknown_fields: self
3556 .__buffa_unknown_fields
3557 .to_owned()
3558 .unwrap_or_default()
3559 .into(),
3560 ..::core::default::Default::default()
3561 }
3562 }
3563 }
3564 impl<'a> ::buffa::ViewEncode<'a> for NullView<'a> {
3565 #[allow(clippy::needless_borrow, clippy::let_and_return)]
3566 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
3567 #[allow(unused_imports)]
3568 use ::buffa::Enumeration as _;
3569 let mut size = 0u32;
3570 size += self.__buffa_unknown_fields.encoded_len() as u32;
3571 size
3572 }
3573 #[allow(clippy::needless_borrow)]
3574 fn write_to(
3575 &self,
3576 _cache: &mut ::buffa::SizeCache,
3577 buf: &mut impl ::buffa::bytes::BufMut,
3578 ) {
3579 #[allow(unused_imports)]
3580 use ::buffa::Enumeration as _;
3581 self.__buffa_unknown_fields.write_to(buf);
3582 }
3583 }
3584 impl<'__a> ::serde::Serialize for NullView<'__a> {
3596 fn serialize<__S: ::serde::Serializer>(
3597 &self,
3598 __s: __S,
3599 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3600 use ::serde::ser::SerializeMap as _;
3601 let mut __map = __s.serialize_map(::core::option::Option::None)?;
3602 __map.end()
3603 }
3604 }
3605 impl<'a> ::buffa::MessageName for NullView<'a> {
3606 const PACKAGE: &'static str = "sql.v1";
3607 const NAME: &'static str = "Null";
3608 const FULL_NAME: &'static str = "sql.v1.Null";
3609 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Null";
3610 }
3611 impl<'v> ::buffa::DefaultViewInstance for NullView<'v> {
3612 fn default_view_instance<'a>() -> &'a Self
3613 where
3614 Self: 'a,
3615 {
3616 static VALUE: ::buffa::__private::OnceBox<NullView<'static>> = ::buffa::__private::OnceBox::new();
3617 VALUE
3618 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
3619 <NullView<'static>>::default(),
3620 ))
3621 }
3622 }
3623 impl ::buffa::ViewReborrow for NullView<'static> {
3624 type Reborrowed<'b> = NullView<'b>;
3625 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
3626 this
3627 }
3628 }
3629 #[derive(Clone, Debug, Default)]
3632 pub struct ListValueView<'a> {
3633 pub elements: ::buffa::RepeatedView<
3635 'a,
3636 super::super::__buffa::view::CellView<'a>,
3637 >,
3638 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3639 }
3640 impl<'a> ListValueView<'a> {
3641 #[doc(hidden)]
3649 pub fn _decode_depth(
3650 buf: &'a [u8],
3651 depth: u32,
3652 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3653 let mut view = Self::default();
3654 view._merge_into_view(buf, depth)?;
3655 ::core::result::Result::Ok(view)
3656 }
3657 #[doc(hidden)]
3665 pub fn _merge_into_view(
3666 &mut self,
3667 buf: &'a [u8],
3668 depth: u32,
3669 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3670 let _ = depth;
3671 #[allow(unused_variables)]
3672 let view = self;
3673 let mut cur: &'a [u8] = buf;
3674 while !cur.is_empty() {
3675 let before_tag = cur;
3676 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
3677 match tag.field_number() {
3678 1u32 => {
3679 if tag.wire_type()
3680 != ::buffa::encoding::WireType::LengthDelimited
3681 {
3682 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3683 field_number: 1u32,
3684 expected: 2u8,
3685 actual: tag.wire_type() as u8,
3686 });
3687 }
3688 if depth == 0 {
3689 return Err(::buffa::DecodeError::RecursionLimitExceeded);
3690 }
3691 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3692 view.elements
3693 .push(
3694 super::super::__buffa::view::CellView::_decode_depth(
3695 sub,
3696 depth - 1,
3697 )?,
3698 );
3699 }
3700 _ => {
3701 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
3702 let span_len = before_tag.len() - cur.len();
3703 view.__buffa_unknown_fields
3704 .push_raw(&before_tag[..span_len]);
3705 }
3706 }
3707 }
3708 ::core::result::Result::Ok(())
3709 }
3710 }
3711 impl<'a> ::buffa::MessageView<'a> for ListValueView<'a> {
3712 type Owned = super::super::ListValue;
3713 fn decode_view(
3714 buf: &'a [u8],
3715 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3716 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
3717 }
3718 fn decode_view_with_limit(
3719 buf: &'a [u8],
3720 depth: u32,
3721 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3722 Self::_decode_depth(buf, depth)
3723 }
3724 fn to_owned_message(&self) -> super::super::ListValue {
3725 self.to_owned_from_source(None)
3726 }
3727 #[allow(clippy::useless_conversion, clippy::needless_update)]
3728 fn to_owned_from_source(
3729 &self,
3730 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
3731 ) -> super::super::ListValue {
3732 #[allow(unused_imports)]
3733 use ::buffa::alloc::string::ToString as _;
3734 let _ = __buffa_src;
3735 super::super::ListValue {
3736 elements: self
3737 .elements
3738 .iter()
3739 .map(|v| v.to_owned_from_source(__buffa_src))
3740 .collect(),
3741 __buffa_unknown_fields: self
3742 .__buffa_unknown_fields
3743 .to_owned()
3744 .unwrap_or_default()
3745 .into(),
3746 ..::core::default::Default::default()
3747 }
3748 }
3749 }
3750 impl<'a> ::buffa::ViewEncode<'a> for ListValueView<'a> {
3751 #[allow(clippy::needless_borrow, clippy::let_and_return)]
3752 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
3753 #[allow(unused_imports)]
3754 use ::buffa::Enumeration as _;
3755 let mut size = 0u32;
3756 for v in &self.elements {
3757 let __slot = __cache.reserve();
3758 let inner_size = v.compute_size(__cache);
3759 __cache.set(__slot, inner_size);
3760 size
3761 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3762 + inner_size;
3763 }
3764 size += self.__buffa_unknown_fields.encoded_len() as u32;
3765 size
3766 }
3767 #[allow(clippy::needless_borrow)]
3768 fn write_to(
3769 &self,
3770 __cache: &mut ::buffa::SizeCache,
3771 buf: &mut impl ::buffa::bytes::BufMut,
3772 ) {
3773 #[allow(unused_imports)]
3774 use ::buffa::Enumeration as _;
3775 for v in &self.elements {
3776 ::buffa::encoding::Tag::new(
3777 1u32,
3778 ::buffa::encoding::WireType::LengthDelimited,
3779 )
3780 .encode(buf);
3781 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
3782 v.write_to(__cache, buf);
3783 }
3784 self.__buffa_unknown_fields.write_to(buf);
3785 }
3786 }
3787 impl<'__a> ::serde::Serialize for ListValueView<'__a> {
3799 fn serialize<__S: ::serde::Serializer>(
3800 &self,
3801 __s: __S,
3802 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3803 use ::serde::ser::SerializeMap as _;
3804 let mut __map = __s.serialize_map(::core::option::Option::None)?;
3805 if !self.elements.is_empty() {
3806 __map.serialize_entry("elements", &*self.elements)?;
3807 }
3808 __map.end()
3809 }
3810 }
3811 impl<'a> ::buffa::MessageName for ListValueView<'a> {
3812 const PACKAGE: &'static str = "sql.v1";
3813 const NAME: &'static str = "ListValue";
3814 const FULL_NAME: &'static str = "sql.v1.ListValue";
3815 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.ListValue";
3816 }
3817 impl<'v> ::buffa::DefaultViewInstance for ListValueView<'v> {
3818 fn default_view_instance<'a>() -> &'a Self
3819 where
3820 Self: 'a,
3821 {
3822 static VALUE: ::buffa::__private::OnceBox<ListValueView<'static>> = ::buffa::__private::OnceBox::new();
3823 VALUE
3824 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
3825 <ListValueView<'static>>::default(),
3826 ))
3827 }
3828 }
3829 impl ::buffa::ViewReborrow for ListValueView<'static> {
3830 type Reborrowed<'b> = ListValueView<'b>;
3831 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
3832 this
3833 }
3834 }
3835 #[derive(Clone, Debug, Default)]
3839 pub struct CellView<'a> {
3840 pub kind: ::core::option::Option<
3841 super::super::__buffa::view::oneof::cell::Kind<'a>,
3842 >,
3843 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3844 }
3845 impl<'a> CellView<'a> {
3846 #[doc(hidden)]
3854 pub fn _decode_depth(
3855 buf: &'a [u8],
3856 depth: u32,
3857 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3858 let mut view = Self::default();
3859 view._merge_into_view(buf, depth)?;
3860 ::core::result::Result::Ok(view)
3861 }
3862 #[doc(hidden)]
3870 pub fn _merge_into_view(
3871 &mut self,
3872 buf: &'a [u8],
3873 depth: u32,
3874 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3875 let _ = depth;
3876 #[allow(unused_variables)]
3877 let view = self;
3878 let mut cur: &'a [u8] = buf;
3879 while !cur.is_empty() {
3880 let before_tag = cur;
3881 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
3882 match tag.field_number() {
3883 1u32 => {
3884 if tag.wire_type()
3885 != ::buffa::encoding::WireType::LengthDelimited
3886 {
3887 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3888 field_number: 1u32,
3889 expected: 2u8,
3890 actual: tag.wire_type() as u8,
3891 });
3892 }
3893 if depth == 0 {
3894 return Err(::buffa::DecodeError::RecursionLimitExceeded);
3895 }
3896 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3897 if let Some(
3898 super::super::__buffa::view::oneof::cell::Kind::NullValue(
3899 ref mut existing,
3900 ),
3901 ) = view.kind
3902 {
3903 existing._merge_into_view(sub, depth - 1)?;
3904 } else {
3905 view.kind = Some(
3906 super::super::__buffa::view::oneof::cell::Kind::NullValue(
3907 ::buffa::alloc::boxed::Box::new(
3908 super::super::__buffa::view::NullView::_decode_depth(
3909 sub,
3910 depth - 1,
3911 )?,
3912 ),
3913 ),
3914 );
3915 }
3916 }
3917 2u32 => {
3918 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3919 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3920 field_number: 2u32,
3921 expected: 0u8,
3922 actual: tag.wire_type() as u8,
3923 });
3924 }
3925 view.kind = Some(
3926 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
3927 ::buffa::types::decode_int64(&mut cur)?,
3928 ),
3929 );
3930 }
3931 3u32 => {
3932 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3933 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3934 field_number: 3u32,
3935 expected: 0u8,
3936 actual: tag.wire_type() as u8,
3937 });
3938 }
3939 view.kind = Some(
3940 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
3941 ::buffa::types::decode_uint64(&mut cur)?,
3942 ),
3943 );
3944 }
3945 4u32 => {
3946 if tag.wire_type() != ::buffa::encoding::WireType::Fixed64 {
3947 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3948 field_number: 4u32,
3949 expected: 1u8,
3950 actual: tag.wire_type() as u8,
3951 });
3952 }
3953 view.kind = Some(
3954 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
3955 ::buffa::types::decode_double(&mut cur)?,
3956 ),
3957 );
3958 }
3959 5u32 => {
3960 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3961 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3962 field_number: 5u32,
3963 expected: 0u8,
3964 actual: tag.wire_type() as u8,
3965 });
3966 }
3967 view.kind = Some(
3968 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
3969 ::buffa::types::decode_bool(&mut cur)?,
3970 ),
3971 );
3972 }
3973 6u32 => {
3974 if tag.wire_type()
3975 != ::buffa::encoding::WireType::LengthDelimited
3976 {
3977 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3978 field_number: 6u32,
3979 expected: 2u8,
3980 actual: tag.wire_type() as u8,
3981 });
3982 }
3983 view.kind = Some(
3984 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(
3985 ::buffa::types::borrow_str(&mut cur)?,
3986 ),
3987 );
3988 }
3989 7u32 => {
3990 if tag.wire_type()
3991 != ::buffa::encoding::WireType::LengthDelimited
3992 {
3993 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3994 field_number: 7u32,
3995 expected: 2u8,
3996 actual: tag.wire_type() as u8,
3997 });
3998 }
3999 view.kind = Some(
4000 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
4001 ::buffa::types::borrow_bytes(&mut cur)?,
4002 ),
4003 );
4004 }
4005 8u32 => {
4006 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4007 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4008 field_number: 8u32,
4009 expected: 0u8,
4010 actual: tag.wire_type() as u8,
4011 });
4012 }
4013 view.kind = Some(
4014 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
4015 ::buffa::types::decode_int32(&mut cur)?,
4016 ),
4017 );
4018 }
4019 9u32 => {
4020 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4021 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4022 field_number: 9u32,
4023 expected: 0u8,
4024 actual: tag.wire_type() as u8,
4025 });
4026 }
4027 view.kind = Some(
4028 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
4029 ::buffa::types::decode_int64(&mut cur)?,
4030 ),
4031 );
4032 }
4033 10u32 => {
4034 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4035 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4036 field_number: 10u32,
4037 expected: 0u8,
4038 actual: tag.wire_type() as u8,
4039 });
4040 }
4041 view.kind = Some(
4042 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
4043 ::buffa::types::decode_int64(&mut cur)?,
4044 ),
4045 );
4046 }
4047 11u32 => {
4048 if tag.wire_type()
4049 != ::buffa::encoding::WireType::LengthDelimited
4050 {
4051 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4052 field_number: 11u32,
4053 expected: 2u8,
4054 actual: tag.wire_type() as u8,
4055 });
4056 }
4057 view.kind = Some(
4058 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4059 ::buffa::types::borrow_bytes(&mut cur)?,
4060 ),
4061 );
4062 }
4063 12u32 => {
4064 if tag.wire_type()
4065 != ::buffa::encoding::WireType::LengthDelimited
4066 {
4067 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4068 field_number: 12u32,
4069 expected: 2u8,
4070 actual: tag.wire_type() as u8,
4071 });
4072 }
4073 view.kind = Some(
4074 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4075 ::buffa::types::borrow_bytes(&mut cur)?,
4076 ),
4077 );
4078 }
4079 13u32 => {
4080 if tag.wire_type()
4081 != ::buffa::encoding::WireType::LengthDelimited
4082 {
4083 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4084 field_number: 13u32,
4085 expected: 2u8,
4086 actual: tag.wire_type() as u8,
4087 });
4088 }
4089 if depth == 0 {
4090 return Err(::buffa::DecodeError::RecursionLimitExceeded);
4091 }
4092 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
4093 if let Some(
4094 super::super::__buffa::view::oneof::cell::Kind::ListValue(
4095 ref mut existing,
4096 ),
4097 ) = view.kind
4098 {
4099 existing._merge_into_view(sub, depth - 1)?;
4100 } else {
4101 view.kind = Some(
4102 super::super::__buffa::view::oneof::cell::Kind::ListValue(
4103 ::buffa::alloc::boxed::Box::new(
4104 super::super::__buffa::view::ListValueView::_decode_depth(
4105 sub,
4106 depth - 1,
4107 )?,
4108 ),
4109 ),
4110 );
4111 }
4112 }
4113 14u32 => {
4114 if tag.wire_type()
4115 != ::buffa::encoding::WireType::LengthDelimited
4116 {
4117 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4118 field_number: 14u32,
4119 expected: 2u8,
4120 actual: tag.wire_type() as u8,
4121 });
4122 }
4123 view.kind = Some(
4124 super::super::__buffa::view::oneof::cell::Kind::BinaryValue(
4125 ::buffa::types::borrow_bytes(&mut cur)?,
4126 ),
4127 );
4128 }
4129 _ => {
4130 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
4131 let span_len = before_tag.len() - cur.len();
4132 view.__buffa_unknown_fields
4133 .push_raw(&before_tag[..span_len]);
4134 }
4135 }
4136 }
4137 ::core::result::Result::Ok(())
4138 }
4139 }
4140 impl<'a> ::buffa::MessageView<'a> for CellView<'a> {
4141 type Owned = super::super::Cell;
4142 fn decode_view(
4143 buf: &'a [u8],
4144 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4145 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
4146 }
4147 fn decode_view_with_limit(
4148 buf: &'a [u8],
4149 depth: u32,
4150 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4151 Self::_decode_depth(buf, depth)
4152 }
4153 fn to_owned_message(&self) -> super::super::Cell {
4154 self.to_owned_from_source(None)
4155 }
4156 #[allow(clippy::useless_conversion, clippy::needless_update)]
4157 fn to_owned_from_source(
4158 &self,
4159 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
4160 ) -> super::super::Cell {
4161 #[allow(unused_imports)]
4162 use ::buffa::alloc::string::ToString as _;
4163 let _ = __buffa_src;
4164 super::super::Cell {
4165 kind: self
4166 .kind
4167 .as_ref()
4168 .map(|v| match v {
4169 super::super::__buffa::view::oneof::cell::Kind::NullValue(
4170 v,
4171 ) => {
4172 super::super::__buffa::oneof::cell::Kind::NullValue(
4173 ::buffa::alloc::boxed::Box::new(
4174 v.to_owned_from_source(__buffa_src),
4175 ),
4176 )
4177 }
4178 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
4179 v,
4180 ) => super::super::__buffa::oneof::cell::Kind::Int64Value(*v),
4181 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
4182 v,
4183 ) => {
4184 super::super::__buffa::oneof::cell::Kind::Uint64Value(*v)
4185 }
4186 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
4187 v,
4188 ) => {
4189 super::super::__buffa::oneof::cell::Kind::Float64Value(*v)
4190 }
4191 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
4192 v,
4193 ) => {
4194 super::super::__buffa::oneof::cell::Kind::BooleanValue(*v)
4195 }
4196 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(
4197 v,
4198 ) => {
4199 super::super::__buffa::oneof::cell::Kind::Utf8Value(
4200 v.to_string(),
4201 )
4202 }
4203 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
4204 v,
4205 ) => {
4206 super::super::__buffa::oneof::cell::Kind::FixedSizeBinaryValue(
4207 ::buffa::view::bytes_from_source(__buffa_src, v),
4208 )
4209 }
4210 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
4211 v,
4212 ) => {
4213 super::super::__buffa::oneof::cell::Kind::Date32Value(*v)
4214 }
4215 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
4216 v,
4217 ) => {
4218 super::super::__buffa::oneof::cell::Kind::Date64Value(*v)
4219 }
4220 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
4221 v,
4222 ) => {
4223 super::super::__buffa::oneof::cell::Kind::TimestampValue(*v)
4224 }
4225 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4226 v,
4227 ) => {
4228 super::super::__buffa::oneof::cell::Kind::Decimal128Value(
4229 ::buffa::view::bytes_from_source(__buffa_src, v),
4230 )
4231 }
4232 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4233 v,
4234 ) => {
4235 super::super::__buffa::oneof::cell::Kind::Decimal256Value(
4236 ::buffa::view::bytes_from_source(__buffa_src, v),
4237 )
4238 }
4239 super::super::__buffa::view::oneof::cell::Kind::ListValue(
4240 v,
4241 ) => {
4242 super::super::__buffa::oneof::cell::Kind::ListValue(
4243 ::buffa::alloc::boxed::Box::new(
4244 v.to_owned_from_source(__buffa_src),
4245 ),
4246 )
4247 }
4248 super::super::__buffa::view::oneof::cell::Kind::BinaryValue(
4249 v,
4250 ) => {
4251 super::super::__buffa::oneof::cell::Kind::BinaryValue(
4252 ::buffa::view::bytes_from_source(__buffa_src, v),
4253 )
4254 }
4255 }),
4256 __buffa_unknown_fields: self
4257 .__buffa_unknown_fields
4258 .to_owned()
4259 .unwrap_or_default()
4260 .into(),
4261 ..::core::default::Default::default()
4262 }
4263 }
4264 }
4265 impl<'a> ::buffa::ViewEncode<'a> for CellView<'a> {
4266 #[allow(clippy::needless_borrow, clippy::let_and_return)]
4267 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
4268 #[allow(unused_imports)]
4269 use ::buffa::Enumeration as _;
4270 let mut size = 0u32;
4271 if let ::core::option::Option::Some(ref v) = self.kind {
4272 match v {
4273 super::super::__buffa::view::oneof::cell::Kind::NullValue(x) => {
4274 let __slot = __cache.reserve();
4275 let inner = x.compute_size(__cache);
4276 __cache.set(__slot, inner);
4277 size
4278 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
4279 + inner;
4280 }
4281 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
4282 v,
4283 ) => {
4284 size += 1u32 + ::buffa::types::int64_encoded_len(*v) as u32;
4285 }
4286 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
4287 v,
4288 ) => {
4289 size += 1u32 + ::buffa::types::uint64_encoded_len(*v) as u32;
4290 }
4291 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
4292 _x,
4293 ) => {
4294 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
4295 }
4296 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
4297 _x,
4298 ) => {
4299 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4300 }
4301 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(x) => {
4302 size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
4303 }
4304 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
4305 x,
4306 ) => {
4307 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
4308 }
4309 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
4310 v,
4311 ) => {
4312 size += 1u32 + ::buffa::types::int32_encoded_len(*v) as u32;
4313 }
4314 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
4315 v,
4316 ) => {
4317 size += 1u32 + ::buffa::types::int64_encoded_len(*v) as u32;
4318 }
4319 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
4320 v,
4321 ) => {
4322 size += 1u32 + ::buffa::types::int64_encoded_len(*v) as u32;
4323 }
4324 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4325 x,
4326 ) => {
4327 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
4328 }
4329 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4330 x,
4331 ) => {
4332 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
4333 }
4334 super::super::__buffa::view::oneof::cell::Kind::ListValue(x) => {
4335 let __slot = __cache.reserve();
4336 let inner = x.compute_size(__cache);
4337 __cache.set(__slot, inner);
4338 size
4339 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
4340 + inner;
4341 }
4342 super::super::__buffa::view::oneof::cell::Kind::BinaryValue(
4343 x,
4344 ) => {
4345 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
4346 }
4347 }
4348 }
4349 size += self.__buffa_unknown_fields.encoded_len() as u32;
4350 size
4351 }
4352 #[allow(clippy::needless_borrow)]
4353 fn write_to(
4354 &self,
4355 __cache: &mut ::buffa::SizeCache,
4356 buf: &mut impl ::buffa::bytes::BufMut,
4357 ) {
4358 #[allow(unused_imports)]
4359 use ::buffa::Enumeration as _;
4360 if let ::core::option::Option::Some(ref v) = self.kind {
4361 match v {
4362 super::super::__buffa::view::oneof::cell::Kind::NullValue(x) => {
4363 ::buffa::encoding::Tag::new(
4364 1u32,
4365 ::buffa::encoding::WireType::LengthDelimited,
4366 )
4367 .encode(buf);
4368 ::buffa::encoding::encode_varint(
4369 __cache.consume_next() as u64,
4370 buf,
4371 );
4372 x.write_to(__cache, buf);
4373 }
4374 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
4375 x,
4376 ) => {
4377 ::buffa::encoding::Tag::new(
4378 2u32,
4379 ::buffa::encoding::WireType::Varint,
4380 )
4381 .encode(buf);
4382 ::buffa::types::encode_int64(*x, buf);
4383 }
4384 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
4385 x,
4386 ) => {
4387 ::buffa::encoding::Tag::new(
4388 3u32,
4389 ::buffa::encoding::WireType::Varint,
4390 )
4391 .encode(buf);
4392 ::buffa::types::encode_uint64(*x, buf);
4393 }
4394 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
4395 x,
4396 ) => {
4397 ::buffa::encoding::Tag::new(
4398 4u32,
4399 ::buffa::encoding::WireType::Fixed64,
4400 )
4401 .encode(buf);
4402 ::buffa::types::encode_double(*x, buf);
4403 }
4404 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
4405 x,
4406 ) => {
4407 ::buffa::encoding::Tag::new(
4408 5u32,
4409 ::buffa::encoding::WireType::Varint,
4410 )
4411 .encode(buf);
4412 ::buffa::types::encode_bool(*x, buf);
4413 }
4414 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(x) => {
4415 ::buffa::encoding::Tag::new(
4416 6u32,
4417 ::buffa::encoding::WireType::LengthDelimited,
4418 )
4419 .encode(buf);
4420 ::buffa::types::encode_string(x, buf);
4421 }
4422 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
4423 x,
4424 ) => {
4425 ::buffa::encoding::Tag::new(
4426 7u32,
4427 ::buffa::encoding::WireType::LengthDelimited,
4428 )
4429 .encode(buf);
4430 ::buffa::types::encode_bytes(x, buf);
4431 }
4432 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
4433 x,
4434 ) => {
4435 ::buffa::encoding::Tag::new(
4436 8u32,
4437 ::buffa::encoding::WireType::Varint,
4438 )
4439 .encode(buf);
4440 ::buffa::types::encode_int32(*x, buf);
4441 }
4442 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
4443 x,
4444 ) => {
4445 ::buffa::encoding::Tag::new(
4446 9u32,
4447 ::buffa::encoding::WireType::Varint,
4448 )
4449 .encode(buf);
4450 ::buffa::types::encode_int64(*x, buf);
4451 }
4452 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
4453 x,
4454 ) => {
4455 ::buffa::encoding::Tag::new(
4456 10u32,
4457 ::buffa::encoding::WireType::Varint,
4458 )
4459 .encode(buf);
4460 ::buffa::types::encode_int64(*x, buf);
4461 }
4462 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4463 x,
4464 ) => {
4465 ::buffa::encoding::Tag::new(
4466 11u32,
4467 ::buffa::encoding::WireType::LengthDelimited,
4468 )
4469 .encode(buf);
4470 ::buffa::types::encode_bytes(x, buf);
4471 }
4472 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4473 x,
4474 ) => {
4475 ::buffa::encoding::Tag::new(
4476 12u32,
4477 ::buffa::encoding::WireType::LengthDelimited,
4478 )
4479 .encode(buf);
4480 ::buffa::types::encode_bytes(x, buf);
4481 }
4482 super::super::__buffa::view::oneof::cell::Kind::ListValue(x) => {
4483 ::buffa::encoding::Tag::new(
4484 13u32,
4485 ::buffa::encoding::WireType::LengthDelimited,
4486 )
4487 .encode(buf);
4488 ::buffa::encoding::encode_varint(
4489 __cache.consume_next() as u64,
4490 buf,
4491 );
4492 x.write_to(__cache, buf);
4493 }
4494 super::super::__buffa::view::oneof::cell::Kind::BinaryValue(
4495 x,
4496 ) => {
4497 ::buffa::encoding::Tag::new(
4498 14u32,
4499 ::buffa::encoding::WireType::LengthDelimited,
4500 )
4501 .encode(buf);
4502 ::buffa::types::encode_bytes(x, buf);
4503 }
4504 }
4505 }
4506 self.__buffa_unknown_fields.write_to(buf);
4507 }
4508 }
4509 impl<'__a> ::serde::Serialize for CellView<'__a> {
4521 fn serialize<__S: ::serde::Serializer>(
4522 &self,
4523 __s: __S,
4524 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4525 use ::serde::ser::SerializeMap as _;
4526 let mut __map = __s.serialize_map(::core::option::Option::None)?;
4527 if let ::core::option::Option::Some(ref __ov) = self.kind {
4528 match __ov {
4529 super::super::__buffa::view::oneof::cell::Kind::NullValue(v) => {
4530 __map.serialize_entry("nullValue", v)?;
4531 }
4532 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
4533 v,
4534 ) => {
4535 struct _W(i64);
4536 impl ::serde::Serialize for _W {
4537 fn serialize<__S: ::serde::Serializer>(
4538 &self,
4539 __s: __S,
4540 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4541 ::buffa::json_helpers::int64::serialize(&self.0, __s)
4542 }
4543 }
4544 __map.serialize_entry("int64Value", &_W(*v))?;
4545 }
4546 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
4547 v,
4548 ) => {
4549 struct _W(u64);
4550 impl ::serde::Serialize for _W {
4551 fn serialize<__S: ::serde::Serializer>(
4552 &self,
4553 __s: __S,
4554 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4555 ::buffa::json_helpers::uint64::serialize(&self.0, __s)
4556 }
4557 }
4558 __map.serialize_entry("uint64Value", &_W(*v))?;
4559 }
4560 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
4561 v,
4562 ) => {
4563 struct _W(f64);
4564 impl ::serde::Serialize for _W {
4565 fn serialize<__S: ::serde::Serializer>(
4566 &self,
4567 __s: __S,
4568 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4569 ::buffa::json_helpers::double::serialize(&self.0, __s)
4570 }
4571 }
4572 __map.serialize_entry("float64Value", &_W(*v))?;
4573 }
4574 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
4575 v,
4576 ) => {
4577 __map.serialize_entry("booleanValue", v)?;
4578 }
4579 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(v) => {
4580 __map.serialize_entry("utf8Value", v)?;
4581 }
4582 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
4583 v,
4584 ) => {
4585 struct _W<'__x>(&'__x [u8]);
4586 impl ::serde::Serialize for _W<'_> {
4587 fn serialize<__S: ::serde::Serializer>(
4588 &self,
4589 __s: __S,
4590 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4591 ::buffa::json_helpers::bytes::serialize(self.0, __s)
4592 }
4593 }
4594 __map.serialize_entry("fixedSizeBinaryValue", &_W(v))?;
4595 }
4596 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
4597 v,
4598 ) => {
4599 struct _W(i32);
4600 impl ::serde::Serialize for _W {
4601 fn serialize<__S: ::serde::Serializer>(
4602 &self,
4603 __s: __S,
4604 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4605 ::buffa::json_helpers::int32::serialize(&self.0, __s)
4606 }
4607 }
4608 __map.serialize_entry("date32Value", &_W(*v))?;
4609 }
4610 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
4611 v,
4612 ) => {
4613 struct _W(i64);
4614 impl ::serde::Serialize for _W {
4615 fn serialize<__S: ::serde::Serializer>(
4616 &self,
4617 __s: __S,
4618 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4619 ::buffa::json_helpers::int64::serialize(&self.0, __s)
4620 }
4621 }
4622 __map.serialize_entry("date64Value", &_W(*v))?;
4623 }
4624 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
4625 v,
4626 ) => {
4627 struct _W(i64);
4628 impl ::serde::Serialize for _W {
4629 fn serialize<__S: ::serde::Serializer>(
4630 &self,
4631 __s: __S,
4632 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4633 ::buffa::json_helpers::int64::serialize(&self.0, __s)
4634 }
4635 }
4636 __map.serialize_entry("timestampValue", &_W(*v))?;
4637 }
4638 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4639 v,
4640 ) => {
4641 struct _W<'__x>(&'__x [u8]);
4642 impl ::serde::Serialize for _W<'_> {
4643 fn serialize<__S: ::serde::Serializer>(
4644 &self,
4645 __s: __S,
4646 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4647 ::buffa::json_helpers::bytes::serialize(self.0, __s)
4648 }
4649 }
4650 __map.serialize_entry("decimal128Value", &_W(v))?;
4651 }
4652 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4653 v,
4654 ) => {
4655 struct _W<'__x>(&'__x [u8]);
4656 impl ::serde::Serialize for _W<'_> {
4657 fn serialize<__S: ::serde::Serializer>(
4658 &self,
4659 __s: __S,
4660 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4661 ::buffa::json_helpers::bytes::serialize(self.0, __s)
4662 }
4663 }
4664 __map.serialize_entry("decimal256Value", &_W(v))?;
4665 }
4666 super::super::__buffa::view::oneof::cell::Kind::ListValue(v) => {
4667 __map.serialize_entry("listValue", v)?;
4668 }
4669 super::super::__buffa::view::oneof::cell::Kind::BinaryValue(
4670 v,
4671 ) => {
4672 struct _W<'__x>(&'__x [u8]);
4673 impl ::serde::Serialize for _W<'_> {
4674 fn serialize<__S: ::serde::Serializer>(
4675 &self,
4676 __s: __S,
4677 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4678 ::buffa::json_helpers::bytes::serialize(self.0, __s)
4679 }
4680 }
4681 __map.serialize_entry("binaryValue", &_W(v))?;
4682 }
4683 }
4684 }
4685 __map.end()
4686 }
4687 }
4688 impl<'a> ::buffa::MessageName for CellView<'a> {
4689 const PACKAGE: &'static str = "sql.v1";
4690 const NAME: &'static str = "Cell";
4691 const FULL_NAME: &'static str = "sql.v1.Cell";
4692 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Cell";
4693 }
4694 impl<'v> ::buffa::DefaultViewInstance for CellView<'v> {
4695 fn default_view_instance<'a>() -> &'a Self
4696 where
4697 Self: 'a,
4698 {
4699 static VALUE: ::buffa::__private::OnceBox<CellView<'static>> = ::buffa::__private::OnceBox::new();
4700 VALUE
4701 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
4702 <CellView<'static>>::default(),
4703 ))
4704 }
4705 }
4706 impl ::buffa::ViewReborrow for CellView<'static> {
4707 type Reborrowed<'b> = CellView<'b>;
4708 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
4709 this
4710 }
4711 }
4712 #[derive(Clone, Debug, Default)]
4714 pub struct TablesResponseView<'a> {
4715 pub tables: ::buffa::RepeatedView<
4717 'a,
4718 super::super::__buffa::view::TableView<'a>,
4719 >,
4720 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
4721 }
4722 impl<'a> TablesResponseView<'a> {
4723 #[doc(hidden)]
4731 pub fn _decode_depth(
4732 buf: &'a [u8],
4733 depth: u32,
4734 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4735 let mut view = Self::default();
4736 view._merge_into_view(buf, depth)?;
4737 ::core::result::Result::Ok(view)
4738 }
4739 #[doc(hidden)]
4747 pub fn _merge_into_view(
4748 &mut self,
4749 buf: &'a [u8],
4750 depth: u32,
4751 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
4752 let _ = depth;
4753 #[allow(unused_variables)]
4754 let view = self;
4755 let mut cur: &'a [u8] = buf;
4756 while !cur.is_empty() {
4757 let before_tag = cur;
4758 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
4759 match tag.field_number() {
4760 1u32 => {
4761 if tag.wire_type()
4762 != ::buffa::encoding::WireType::LengthDelimited
4763 {
4764 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4765 field_number: 1u32,
4766 expected: 2u8,
4767 actual: tag.wire_type() as u8,
4768 });
4769 }
4770 if depth == 0 {
4771 return Err(::buffa::DecodeError::RecursionLimitExceeded);
4772 }
4773 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
4774 view.tables
4775 .push(
4776 super::super::__buffa::view::TableView::_decode_depth(
4777 sub,
4778 depth - 1,
4779 )?,
4780 );
4781 }
4782 _ => {
4783 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
4784 let span_len = before_tag.len() - cur.len();
4785 view.__buffa_unknown_fields
4786 .push_raw(&before_tag[..span_len]);
4787 }
4788 }
4789 }
4790 ::core::result::Result::Ok(())
4791 }
4792 }
4793 impl<'a> ::buffa::MessageView<'a> for TablesResponseView<'a> {
4794 type Owned = super::super::TablesResponse;
4795 fn decode_view(
4796 buf: &'a [u8],
4797 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4798 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
4799 }
4800 fn decode_view_with_limit(
4801 buf: &'a [u8],
4802 depth: u32,
4803 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4804 Self::_decode_depth(buf, depth)
4805 }
4806 fn to_owned_message(&self) -> super::super::TablesResponse {
4807 self.to_owned_from_source(None)
4808 }
4809 #[allow(clippy::useless_conversion, clippy::needless_update)]
4810 fn to_owned_from_source(
4811 &self,
4812 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
4813 ) -> super::super::TablesResponse {
4814 #[allow(unused_imports)]
4815 use ::buffa::alloc::string::ToString as _;
4816 let _ = __buffa_src;
4817 super::super::TablesResponse {
4818 tables: self
4819 .tables
4820 .iter()
4821 .map(|v| v.to_owned_from_source(__buffa_src))
4822 .collect(),
4823 __buffa_unknown_fields: self
4824 .__buffa_unknown_fields
4825 .to_owned()
4826 .unwrap_or_default()
4827 .into(),
4828 ..::core::default::Default::default()
4829 }
4830 }
4831 }
4832 impl<'a> ::buffa::ViewEncode<'a> for TablesResponseView<'a> {
4833 #[allow(clippy::needless_borrow, clippy::let_and_return)]
4834 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
4835 #[allow(unused_imports)]
4836 use ::buffa::Enumeration as _;
4837 let mut size = 0u32;
4838 for v in &self.tables {
4839 let __slot = __cache.reserve();
4840 let inner_size = v.compute_size(__cache);
4841 __cache.set(__slot, inner_size);
4842 size
4843 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
4844 + inner_size;
4845 }
4846 size += self.__buffa_unknown_fields.encoded_len() as u32;
4847 size
4848 }
4849 #[allow(clippy::needless_borrow)]
4850 fn write_to(
4851 &self,
4852 __cache: &mut ::buffa::SizeCache,
4853 buf: &mut impl ::buffa::bytes::BufMut,
4854 ) {
4855 #[allow(unused_imports)]
4856 use ::buffa::Enumeration as _;
4857 for v in &self.tables {
4858 ::buffa::encoding::Tag::new(
4859 1u32,
4860 ::buffa::encoding::WireType::LengthDelimited,
4861 )
4862 .encode(buf);
4863 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
4864 v.write_to(__cache, buf);
4865 }
4866 self.__buffa_unknown_fields.write_to(buf);
4867 }
4868 }
4869 impl<'__a> ::serde::Serialize for TablesResponseView<'__a> {
4881 fn serialize<__S: ::serde::Serializer>(
4882 &self,
4883 __s: __S,
4884 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4885 use ::serde::ser::SerializeMap as _;
4886 let mut __map = __s.serialize_map(::core::option::Option::None)?;
4887 if !self.tables.is_empty() {
4888 __map.serialize_entry("tables", &*self.tables)?;
4889 }
4890 __map.end()
4891 }
4892 }
4893 impl<'a> ::buffa::MessageName for TablesResponseView<'a> {
4894 const PACKAGE: &'static str = "sql.v1";
4895 const NAME: &'static str = "TablesResponse";
4896 const FULL_NAME: &'static str = "sql.v1.TablesResponse";
4897 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesResponse";
4898 }
4899 impl<'v> ::buffa::DefaultViewInstance for TablesResponseView<'v> {
4900 fn default_view_instance<'a>() -> &'a Self
4901 where
4902 Self: 'a,
4903 {
4904 static VALUE: ::buffa::__private::OnceBox<TablesResponseView<'static>> = ::buffa::__private::OnceBox::new();
4905 VALUE
4906 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
4907 <TablesResponseView<'static>>::default(),
4908 ))
4909 }
4910 }
4911 impl ::buffa::ViewReborrow for TablesResponseView<'static> {
4912 type Reborrowed<'b> = TablesResponseView<'b>;
4913 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
4914 this
4915 }
4916 }
4917 #[derive(Clone, Debug, Default)]
4919 pub struct TablesRequestView<'a> {
4920 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
4921 }
4922 impl<'a> TablesRequestView<'a> {
4923 #[doc(hidden)]
4931 pub fn _decode_depth(
4932 buf: &'a [u8],
4933 depth: u32,
4934 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4935 let mut view = Self::default();
4936 view._merge_into_view(buf, depth)?;
4937 ::core::result::Result::Ok(view)
4938 }
4939 #[doc(hidden)]
4947 pub fn _merge_into_view(
4948 &mut self,
4949 buf: &'a [u8],
4950 depth: u32,
4951 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
4952 let _ = depth;
4953 #[allow(unused_variables)]
4954 let view = self;
4955 let mut cur: &'a [u8] = buf;
4956 while !cur.is_empty() {
4957 let before_tag = cur;
4958 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
4959 match tag.field_number() {
4960 _ => {
4961 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
4962 let span_len = before_tag.len() - cur.len();
4963 view.__buffa_unknown_fields
4964 .push_raw(&before_tag[..span_len]);
4965 }
4966 }
4967 }
4968 ::core::result::Result::Ok(())
4969 }
4970 }
4971 impl<'a> ::buffa::MessageView<'a> for TablesRequestView<'a> {
4972 type Owned = super::super::TablesRequest;
4973 fn decode_view(
4974 buf: &'a [u8],
4975 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4976 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
4977 }
4978 fn decode_view_with_limit(
4979 buf: &'a [u8],
4980 depth: u32,
4981 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4982 Self::_decode_depth(buf, depth)
4983 }
4984 fn to_owned_message(&self) -> super::super::TablesRequest {
4985 self.to_owned_from_source(None)
4986 }
4987 #[allow(clippy::useless_conversion, clippy::needless_update)]
4988 fn to_owned_from_source(
4989 &self,
4990 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
4991 ) -> super::super::TablesRequest {
4992 #[allow(unused_imports)]
4993 use ::buffa::alloc::string::ToString as _;
4994 let _ = __buffa_src;
4995 super::super::TablesRequest {
4996 __buffa_unknown_fields: self
4997 .__buffa_unknown_fields
4998 .to_owned()
4999 .unwrap_or_default()
5000 .into(),
5001 ..::core::default::Default::default()
5002 }
5003 }
5004 }
5005 impl<'a> ::buffa::ViewEncode<'a> for TablesRequestView<'a> {
5006 #[allow(clippy::needless_borrow, clippy::let_and_return)]
5007 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
5008 #[allow(unused_imports)]
5009 use ::buffa::Enumeration as _;
5010 let mut size = 0u32;
5011 size += self.__buffa_unknown_fields.encoded_len() as u32;
5012 size
5013 }
5014 #[allow(clippy::needless_borrow)]
5015 fn write_to(
5016 &self,
5017 _cache: &mut ::buffa::SizeCache,
5018 buf: &mut impl ::buffa::bytes::BufMut,
5019 ) {
5020 #[allow(unused_imports)]
5021 use ::buffa::Enumeration as _;
5022 self.__buffa_unknown_fields.write_to(buf);
5023 }
5024 }
5025 impl<'__a> ::serde::Serialize for TablesRequestView<'__a> {
5037 fn serialize<__S: ::serde::Serializer>(
5038 &self,
5039 __s: __S,
5040 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5041 use ::serde::ser::SerializeMap as _;
5042 let mut __map = __s.serialize_map(::core::option::Option::None)?;
5043 __map.end()
5044 }
5045 }
5046 impl<'a> ::buffa::MessageName for TablesRequestView<'a> {
5047 const PACKAGE: &'static str = "sql.v1";
5048 const NAME: &'static str = "TablesRequest";
5049 const FULL_NAME: &'static str = "sql.v1.TablesRequest";
5050 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesRequest";
5051 }
5052 impl<'v> ::buffa::DefaultViewInstance for TablesRequestView<'v> {
5053 fn default_view_instance<'a>() -> &'a Self
5054 where
5055 Self: 'a,
5056 {
5057 static VALUE: ::buffa::__private::OnceBox<TablesRequestView<'static>> = ::buffa::__private::OnceBox::new();
5058 VALUE
5059 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
5060 <TablesRequestView<'static>>::default(),
5061 ))
5062 }
5063 }
5064 impl ::buffa::ViewReborrow for TablesRequestView<'static> {
5065 type Reborrowed<'b> = TablesRequestView<'b>;
5066 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
5067 this
5068 }
5069 }
5070 #[derive(Clone, Debug, Default)]
5072 pub struct TableView<'a> {
5073 pub name: &'a str,
5077 pub columns: ::buffa::RepeatedView<
5081 'a,
5082 super::super::__buffa::view::ColumnView<'a>,
5083 >,
5084 pub primary_key_columns: ::buffa::RepeatedView<'a, u32>,
5088 pub indexes: ::buffa::RepeatedView<
5092 'a,
5093 super::super::__buffa::view::IndexView<'a>,
5094 >,
5095 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
5096 }
5097 impl<'a> TableView<'a> {
5098 #[doc(hidden)]
5106 pub fn _decode_depth(
5107 buf: &'a [u8],
5108 depth: u32,
5109 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5110 let mut view = Self::default();
5111 view._merge_into_view(buf, depth)?;
5112 ::core::result::Result::Ok(view)
5113 }
5114 #[doc(hidden)]
5122 pub fn _merge_into_view(
5123 &mut self,
5124 buf: &'a [u8],
5125 depth: u32,
5126 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5127 let _ = depth;
5128 #[allow(unused_variables)]
5129 let view = self;
5130 let mut cur: &'a [u8] = buf;
5131 while !cur.is_empty() {
5132 let before_tag = cur;
5133 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
5134 match tag.field_number() {
5135 1u32 => {
5136 if tag.wire_type()
5137 != ::buffa::encoding::WireType::LengthDelimited
5138 {
5139 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5140 field_number: 1u32,
5141 expected: 2u8,
5142 actual: tag.wire_type() as u8,
5143 });
5144 }
5145 view.name = ::buffa::types::borrow_str(&mut cur)?;
5146 }
5147 2u32 => {
5148 if tag.wire_type()
5149 != ::buffa::encoding::WireType::LengthDelimited
5150 {
5151 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5152 field_number: 2u32,
5153 expected: 2u8,
5154 actual: tag.wire_type() as u8,
5155 });
5156 }
5157 if depth == 0 {
5158 return Err(::buffa::DecodeError::RecursionLimitExceeded);
5159 }
5160 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
5161 view.columns
5162 .push(
5163 super::super::__buffa::view::ColumnView::_decode_depth(
5164 sub,
5165 depth - 1,
5166 )?,
5167 );
5168 }
5169 3u32 => {
5170 if tag.wire_type()
5171 == ::buffa::encoding::WireType::LengthDelimited
5172 {
5173 let payload = ::buffa::types::borrow_bytes(&mut cur)?;
5174 let mut pcur: &[u8] = payload;
5175 while !pcur.is_empty() {
5176 view.primary_key_columns
5177 .push(::buffa::types::decode_uint32(&mut pcur)?);
5178 }
5179 } else if tag.wire_type()
5180 == ::buffa::encoding::WireType::Varint
5181 {
5182 view.primary_key_columns
5183 .push(::buffa::types::decode_uint32(&mut cur)?);
5184 } else {
5185 return Err(::buffa::DecodeError::WireTypeMismatch {
5186 field_number: 3u32,
5187 expected: 2u8,
5188 actual: tag.wire_type() as u8,
5189 });
5190 }
5191 }
5192 4u32 => {
5193 if tag.wire_type()
5194 != ::buffa::encoding::WireType::LengthDelimited
5195 {
5196 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5197 field_number: 4u32,
5198 expected: 2u8,
5199 actual: tag.wire_type() as u8,
5200 });
5201 }
5202 if depth == 0 {
5203 return Err(::buffa::DecodeError::RecursionLimitExceeded);
5204 }
5205 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
5206 view.indexes
5207 .push(
5208 super::super::__buffa::view::IndexView::_decode_depth(
5209 sub,
5210 depth - 1,
5211 )?,
5212 );
5213 }
5214 _ => {
5215 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
5216 let span_len = before_tag.len() - cur.len();
5217 view.__buffa_unknown_fields
5218 .push_raw(&before_tag[..span_len]);
5219 }
5220 }
5221 }
5222 ::core::result::Result::Ok(())
5223 }
5224 }
5225 impl<'a> ::buffa::MessageView<'a> for TableView<'a> {
5226 type Owned = super::super::Table;
5227 fn decode_view(
5228 buf: &'a [u8],
5229 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5230 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
5231 }
5232 fn decode_view_with_limit(
5233 buf: &'a [u8],
5234 depth: u32,
5235 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5236 Self::_decode_depth(buf, depth)
5237 }
5238 fn to_owned_message(&self) -> super::super::Table {
5239 self.to_owned_from_source(None)
5240 }
5241 #[allow(clippy::useless_conversion, clippy::needless_update)]
5242 fn to_owned_from_source(
5243 &self,
5244 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
5245 ) -> super::super::Table {
5246 #[allow(unused_imports)]
5247 use ::buffa::alloc::string::ToString as _;
5248 let _ = __buffa_src;
5249 super::super::Table {
5250 name: self.name.to_string(),
5251 columns: self
5252 .columns
5253 .iter()
5254 .map(|v| v.to_owned_from_source(__buffa_src))
5255 .collect(),
5256 primary_key_columns: self.primary_key_columns.to_vec(),
5257 indexes: self
5258 .indexes
5259 .iter()
5260 .map(|v| v.to_owned_from_source(__buffa_src))
5261 .collect(),
5262 __buffa_unknown_fields: self
5263 .__buffa_unknown_fields
5264 .to_owned()
5265 .unwrap_or_default()
5266 .into(),
5267 ..::core::default::Default::default()
5268 }
5269 }
5270 }
5271 impl<'a> ::buffa::ViewEncode<'a> for TableView<'a> {
5272 #[allow(clippy::needless_borrow, clippy::let_and_return)]
5273 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
5274 #[allow(unused_imports)]
5275 use ::buffa::Enumeration as _;
5276 let mut size = 0u32;
5277 if !self.name.is_empty() {
5278 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
5279 }
5280 for v in &self.columns {
5281 let __slot = __cache.reserve();
5282 let inner_size = v.compute_size(__cache);
5283 __cache.set(__slot, inner_size);
5284 size
5285 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5286 + inner_size;
5287 }
5288 if !self.primary_key_columns.is_empty() {
5289 let payload: u32 = self
5290 .primary_key_columns
5291 .iter()
5292 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5293 .sum::<u32>();
5294 size
5295 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
5296 + payload;
5297 }
5298 for v in &self.indexes {
5299 let __slot = __cache.reserve();
5300 let inner_size = v.compute_size(__cache);
5301 __cache.set(__slot, inner_size);
5302 size
5303 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5304 + inner_size;
5305 }
5306 size += self.__buffa_unknown_fields.encoded_len() as u32;
5307 size
5308 }
5309 #[allow(clippy::needless_borrow)]
5310 fn write_to(
5311 &self,
5312 __cache: &mut ::buffa::SizeCache,
5313 buf: &mut impl ::buffa::bytes::BufMut,
5314 ) {
5315 #[allow(unused_imports)]
5316 use ::buffa::Enumeration as _;
5317 if !self.name.is_empty() {
5318 ::buffa::encoding::Tag::new(
5319 1u32,
5320 ::buffa::encoding::WireType::LengthDelimited,
5321 )
5322 .encode(buf);
5323 ::buffa::types::encode_string(&self.name, buf);
5324 }
5325 for v in &self.columns {
5326 ::buffa::encoding::Tag::new(
5327 2u32,
5328 ::buffa::encoding::WireType::LengthDelimited,
5329 )
5330 .encode(buf);
5331 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
5332 v.write_to(__cache, buf);
5333 }
5334 if !self.primary_key_columns.is_empty() {
5335 let payload: u32 = self
5336 .primary_key_columns
5337 .iter()
5338 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5339 .sum::<u32>();
5340 ::buffa::encoding::Tag::new(
5341 3u32,
5342 ::buffa::encoding::WireType::LengthDelimited,
5343 )
5344 .encode(buf);
5345 ::buffa::encoding::encode_varint(payload as u64, buf);
5346 for &v in &self.primary_key_columns {
5347 ::buffa::types::encode_uint32(v, buf);
5348 }
5349 }
5350 for v in &self.indexes {
5351 ::buffa::encoding::Tag::new(
5352 4u32,
5353 ::buffa::encoding::WireType::LengthDelimited,
5354 )
5355 .encode(buf);
5356 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
5357 v.write_to(__cache, buf);
5358 }
5359 self.__buffa_unknown_fields.write_to(buf);
5360 }
5361 }
5362 impl<'__a> ::serde::Serialize for TableView<'__a> {
5374 fn serialize<__S: ::serde::Serializer>(
5375 &self,
5376 __s: __S,
5377 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5378 use ::serde::ser::SerializeMap as _;
5379 let mut __map = __s.serialize_map(::core::option::Option::None)?;
5380 if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
5381 __map.serialize_entry("name", self.name)?;
5382 }
5383 if !self.columns.is_empty() {
5384 __map.serialize_entry("columns", &*self.columns)?;
5385 }
5386 if !self.primary_key_columns.is_empty() {
5387 struct _WSeq<'__x>(&'__x [u32]);
5388 impl ::serde::Serialize for _WSeq<'_> {
5389 fn serialize<__S: ::serde::Serializer>(
5390 &self,
5391 __s: __S,
5392 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5393 ::buffa::json_helpers::proto_seq::serialize(self.0, __s)
5394 }
5395 }
5396 __map
5397 .serialize_entry(
5398 "primaryKeyColumns",
5399 &_WSeq(&self.primary_key_columns),
5400 )?;
5401 }
5402 if !self.indexes.is_empty() {
5403 __map.serialize_entry("indexes", &*self.indexes)?;
5404 }
5405 __map.end()
5406 }
5407 }
5408 impl<'a> ::buffa::MessageName for TableView<'a> {
5409 const PACKAGE: &'static str = "sql.v1";
5410 const NAME: &'static str = "Table";
5411 const FULL_NAME: &'static str = "sql.v1.Table";
5412 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Table";
5413 }
5414 impl<'v> ::buffa::DefaultViewInstance for TableView<'v> {
5415 fn default_view_instance<'a>() -> &'a Self
5416 where
5417 Self: 'a,
5418 {
5419 static VALUE: ::buffa::__private::OnceBox<TableView<'static>> = ::buffa::__private::OnceBox::new();
5420 VALUE
5421 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
5422 <TableView<'static>>::default(),
5423 ))
5424 }
5425 }
5426 impl ::buffa::ViewReborrow for TableView<'static> {
5427 type Reborrowed<'b> = TableView<'b>;
5428 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
5429 this
5430 }
5431 }
5432 #[derive(Clone, Debug, Default)]
5434 pub struct ColumnView<'a> {
5435 pub name: &'a str,
5437 pub data_type: &'a str,
5443 pub nullable: bool,
5445 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
5446 }
5447 impl<'a> ColumnView<'a> {
5448 #[doc(hidden)]
5456 pub fn _decode_depth(
5457 buf: &'a [u8],
5458 depth: u32,
5459 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5460 let mut view = Self::default();
5461 view._merge_into_view(buf, depth)?;
5462 ::core::result::Result::Ok(view)
5463 }
5464 #[doc(hidden)]
5472 pub fn _merge_into_view(
5473 &mut self,
5474 buf: &'a [u8],
5475 depth: u32,
5476 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5477 let _ = depth;
5478 #[allow(unused_variables)]
5479 let view = self;
5480 let mut cur: &'a [u8] = buf;
5481 while !cur.is_empty() {
5482 let before_tag = cur;
5483 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
5484 match tag.field_number() {
5485 1u32 => {
5486 if tag.wire_type()
5487 != ::buffa::encoding::WireType::LengthDelimited
5488 {
5489 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5490 field_number: 1u32,
5491 expected: 2u8,
5492 actual: tag.wire_type() as u8,
5493 });
5494 }
5495 view.name = ::buffa::types::borrow_str(&mut cur)?;
5496 }
5497 2u32 => {
5498 if tag.wire_type()
5499 != ::buffa::encoding::WireType::LengthDelimited
5500 {
5501 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5502 field_number: 2u32,
5503 expected: 2u8,
5504 actual: tag.wire_type() as u8,
5505 });
5506 }
5507 view.data_type = ::buffa::types::borrow_str(&mut cur)?;
5508 }
5509 3u32 => {
5510 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5511 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5512 field_number: 3u32,
5513 expected: 0u8,
5514 actual: tag.wire_type() as u8,
5515 });
5516 }
5517 view.nullable = ::buffa::types::decode_bool(&mut cur)?;
5518 }
5519 _ => {
5520 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
5521 let span_len = before_tag.len() - cur.len();
5522 view.__buffa_unknown_fields
5523 .push_raw(&before_tag[..span_len]);
5524 }
5525 }
5526 }
5527 ::core::result::Result::Ok(())
5528 }
5529 }
5530 impl<'a> ::buffa::MessageView<'a> for ColumnView<'a> {
5531 type Owned = super::super::Column;
5532 fn decode_view(
5533 buf: &'a [u8],
5534 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5535 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
5536 }
5537 fn decode_view_with_limit(
5538 buf: &'a [u8],
5539 depth: u32,
5540 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5541 Self::_decode_depth(buf, depth)
5542 }
5543 fn to_owned_message(&self) -> super::super::Column {
5544 self.to_owned_from_source(None)
5545 }
5546 #[allow(clippy::useless_conversion, clippy::needless_update)]
5547 fn to_owned_from_source(
5548 &self,
5549 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
5550 ) -> super::super::Column {
5551 #[allow(unused_imports)]
5552 use ::buffa::alloc::string::ToString as _;
5553 let _ = __buffa_src;
5554 super::super::Column {
5555 name: self.name.to_string(),
5556 data_type: self.data_type.to_string(),
5557 nullable: self.nullable,
5558 __buffa_unknown_fields: self
5559 .__buffa_unknown_fields
5560 .to_owned()
5561 .unwrap_or_default()
5562 .into(),
5563 ..::core::default::Default::default()
5564 }
5565 }
5566 }
5567 impl<'a> ::buffa::ViewEncode<'a> for ColumnView<'a> {
5568 #[allow(clippy::needless_borrow, clippy::let_and_return)]
5569 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
5570 #[allow(unused_imports)]
5571 use ::buffa::Enumeration as _;
5572 let mut size = 0u32;
5573 if !self.name.is_empty() {
5574 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
5575 }
5576 if !self.data_type.is_empty() {
5577 size
5578 += 1u32
5579 + ::buffa::types::string_encoded_len(&self.data_type) as u32;
5580 }
5581 if self.nullable {
5582 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
5583 }
5584 size += self.__buffa_unknown_fields.encoded_len() as u32;
5585 size
5586 }
5587 #[allow(clippy::needless_borrow)]
5588 fn write_to(
5589 &self,
5590 _cache: &mut ::buffa::SizeCache,
5591 buf: &mut impl ::buffa::bytes::BufMut,
5592 ) {
5593 #[allow(unused_imports)]
5594 use ::buffa::Enumeration as _;
5595 if !self.name.is_empty() {
5596 ::buffa::encoding::Tag::new(
5597 1u32,
5598 ::buffa::encoding::WireType::LengthDelimited,
5599 )
5600 .encode(buf);
5601 ::buffa::types::encode_string(&self.name, buf);
5602 }
5603 if !self.data_type.is_empty() {
5604 ::buffa::encoding::Tag::new(
5605 2u32,
5606 ::buffa::encoding::WireType::LengthDelimited,
5607 )
5608 .encode(buf);
5609 ::buffa::types::encode_string(&self.data_type, buf);
5610 }
5611 if self.nullable {
5612 ::buffa::encoding::Tag::new(
5613 3u32,
5614 ::buffa::encoding::WireType::Varint,
5615 )
5616 .encode(buf);
5617 ::buffa::types::encode_bool(self.nullable, buf);
5618 }
5619 self.__buffa_unknown_fields.write_to(buf);
5620 }
5621 }
5622 impl<'__a> ::serde::Serialize for ColumnView<'__a> {
5634 fn serialize<__S: ::serde::Serializer>(
5635 &self,
5636 __s: __S,
5637 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5638 use ::serde::ser::SerializeMap as _;
5639 let mut __map = __s.serialize_map(::core::option::Option::None)?;
5640 if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
5641 __map.serialize_entry("name", self.name)?;
5642 }
5643 if !::buffa::json_helpers::skip_if::is_empty_str(self.data_type) {
5644 __map.serialize_entry("dataType", self.data_type)?;
5645 }
5646 if self.nullable {
5647 __map.serialize_entry("nullable", &self.nullable)?;
5648 }
5649 __map.end()
5650 }
5651 }
5652 impl<'a> ::buffa::MessageName for ColumnView<'a> {
5653 const PACKAGE: &'static str = "sql.v1";
5654 const NAME: &'static str = "Column";
5655 const FULL_NAME: &'static str = "sql.v1.Column";
5656 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Column";
5657 }
5658 impl<'v> ::buffa::DefaultViewInstance for ColumnView<'v> {
5659 fn default_view_instance<'a>() -> &'a Self
5660 where
5661 Self: 'a,
5662 {
5663 static VALUE: ::buffa::__private::OnceBox<ColumnView<'static>> = ::buffa::__private::OnceBox::new();
5664 VALUE
5665 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
5666 <ColumnView<'static>>::default(),
5667 ))
5668 }
5669 }
5670 impl ::buffa::ViewReborrow for ColumnView<'static> {
5671 type Reborrowed<'b> = ColumnView<'b>;
5672 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
5673 this
5674 }
5675 }
5676 #[derive(Clone, Debug, Default)]
5678 pub struct IndexView<'a> {
5679 pub name: &'a str,
5681 pub layout: ::buffa::EnumValue<super::super::IndexLayout>,
5683 pub key_columns: ::buffa::RepeatedView<'a, u32>,
5687 pub cover_columns: ::buffa::RepeatedView<'a, u32>,
5692 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
5693 }
5694 impl<'a> IndexView<'a> {
5695 #[doc(hidden)]
5703 pub fn _decode_depth(
5704 buf: &'a [u8],
5705 depth: u32,
5706 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5707 let mut view = Self::default();
5708 view._merge_into_view(buf, depth)?;
5709 ::core::result::Result::Ok(view)
5710 }
5711 #[doc(hidden)]
5719 pub fn _merge_into_view(
5720 &mut self,
5721 buf: &'a [u8],
5722 depth: u32,
5723 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5724 let _ = depth;
5725 #[allow(unused_variables)]
5726 let view = self;
5727 let mut cur: &'a [u8] = buf;
5728 while !cur.is_empty() {
5729 let before_tag = cur;
5730 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
5731 match tag.field_number() {
5732 1u32 => {
5733 if tag.wire_type()
5734 != ::buffa::encoding::WireType::LengthDelimited
5735 {
5736 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5737 field_number: 1u32,
5738 expected: 2u8,
5739 actual: tag.wire_type() as u8,
5740 });
5741 }
5742 view.name = ::buffa::types::borrow_str(&mut cur)?;
5743 }
5744 2u32 => {
5745 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5746 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5747 field_number: 2u32,
5748 expected: 0u8,
5749 actual: tag.wire_type() as u8,
5750 });
5751 }
5752 view.layout = ::buffa::EnumValue::from(
5753 ::buffa::types::decode_int32(&mut cur)?,
5754 );
5755 }
5756 3u32 => {
5757 if tag.wire_type()
5758 == ::buffa::encoding::WireType::LengthDelimited
5759 {
5760 let payload = ::buffa::types::borrow_bytes(&mut cur)?;
5761 let mut pcur: &[u8] = payload;
5762 while !pcur.is_empty() {
5763 view.key_columns
5764 .push(::buffa::types::decode_uint32(&mut pcur)?);
5765 }
5766 } else if tag.wire_type()
5767 == ::buffa::encoding::WireType::Varint
5768 {
5769 view.key_columns
5770 .push(::buffa::types::decode_uint32(&mut cur)?);
5771 } else {
5772 return Err(::buffa::DecodeError::WireTypeMismatch {
5773 field_number: 3u32,
5774 expected: 2u8,
5775 actual: tag.wire_type() as u8,
5776 });
5777 }
5778 }
5779 4u32 => {
5780 if tag.wire_type()
5781 == ::buffa::encoding::WireType::LengthDelimited
5782 {
5783 let payload = ::buffa::types::borrow_bytes(&mut cur)?;
5784 let mut pcur: &[u8] = payload;
5785 while !pcur.is_empty() {
5786 view.cover_columns
5787 .push(::buffa::types::decode_uint32(&mut pcur)?);
5788 }
5789 } else if tag.wire_type()
5790 == ::buffa::encoding::WireType::Varint
5791 {
5792 view.cover_columns
5793 .push(::buffa::types::decode_uint32(&mut cur)?);
5794 } else {
5795 return Err(::buffa::DecodeError::WireTypeMismatch {
5796 field_number: 4u32,
5797 expected: 2u8,
5798 actual: tag.wire_type() as u8,
5799 });
5800 }
5801 }
5802 _ => {
5803 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
5804 let span_len = before_tag.len() - cur.len();
5805 view.__buffa_unknown_fields
5806 .push_raw(&before_tag[..span_len]);
5807 }
5808 }
5809 }
5810 ::core::result::Result::Ok(())
5811 }
5812 }
5813 impl<'a> ::buffa::MessageView<'a> for IndexView<'a> {
5814 type Owned = super::super::Index;
5815 fn decode_view(
5816 buf: &'a [u8],
5817 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5818 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
5819 }
5820 fn decode_view_with_limit(
5821 buf: &'a [u8],
5822 depth: u32,
5823 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5824 Self::_decode_depth(buf, depth)
5825 }
5826 fn to_owned_message(&self) -> super::super::Index {
5827 self.to_owned_from_source(None)
5828 }
5829 #[allow(clippy::useless_conversion, clippy::needless_update)]
5830 fn to_owned_from_source(
5831 &self,
5832 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
5833 ) -> super::super::Index {
5834 #[allow(unused_imports)]
5835 use ::buffa::alloc::string::ToString as _;
5836 let _ = __buffa_src;
5837 super::super::Index {
5838 name: self.name.to_string(),
5839 layout: self.layout,
5840 key_columns: self.key_columns.to_vec(),
5841 cover_columns: self.cover_columns.to_vec(),
5842 __buffa_unknown_fields: self
5843 .__buffa_unknown_fields
5844 .to_owned()
5845 .unwrap_or_default()
5846 .into(),
5847 ..::core::default::Default::default()
5848 }
5849 }
5850 }
5851 impl<'a> ::buffa::ViewEncode<'a> for IndexView<'a> {
5852 #[allow(clippy::needless_borrow, clippy::let_and_return)]
5853 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
5854 #[allow(unused_imports)]
5855 use ::buffa::Enumeration as _;
5856 let mut size = 0u32;
5857 if !self.name.is_empty() {
5858 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
5859 }
5860 {
5861 let val = self.layout.to_i32();
5862 if val != 0 {
5863 size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
5864 }
5865 }
5866 if !self.key_columns.is_empty() {
5867 let payload: u32 = self
5868 .key_columns
5869 .iter()
5870 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5871 .sum::<u32>();
5872 size
5873 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
5874 + payload;
5875 }
5876 if !self.cover_columns.is_empty() {
5877 let payload: u32 = self
5878 .cover_columns
5879 .iter()
5880 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5881 .sum::<u32>();
5882 size
5883 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
5884 + payload;
5885 }
5886 size += self.__buffa_unknown_fields.encoded_len() as u32;
5887 size
5888 }
5889 #[allow(clippy::needless_borrow)]
5890 fn write_to(
5891 &self,
5892 _cache: &mut ::buffa::SizeCache,
5893 buf: &mut impl ::buffa::bytes::BufMut,
5894 ) {
5895 #[allow(unused_imports)]
5896 use ::buffa::Enumeration as _;
5897 if !self.name.is_empty() {
5898 ::buffa::encoding::Tag::new(
5899 1u32,
5900 ::buffa::encoding::WireType::LengthDelimited,
5901 )
5902 .encode(buf);
5903 ::buffa::types::encode_string(&self.name, buf);
5904 }
5905 {
5906 let val = self.layout.to_i32();
5907 if val != 0 {
5908 ::buffa::encoding::Tag::new(
5909 2u32,
5910 ::buffa::encoding::WireType::Varint,
5911 )
5912 .encode(buf);
5913 ::buffa::types::encode_int32(val, buf);
5914 }
5915 }
5916 if !self.key_columns.is_empty() {
5917 let payload: u32 = self
5918 .key_columns
5919 .iter()
5920 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5921 .sum::<u32>();
5922 ::buffa::encoding::Tag::new(
5923 3u32,
5924 ::buffa::encoding::WireType::LengthDelimited,
5925 )
5926 .encode(buf);
5927 ::buffa::encoding::encode_varint(payload as u64, buf);
5928 for &v in &self.key_columns {
5929 ::buffa::types::encode_uint32(v, buf);
5930 }
5931 }
5932 if !self.cover_columns.is_empty() {
5933 let payload: u32 = self
5934 .cover_columns
5935 .iter()
5936 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5937 .sum::<u32>();
5938 ::buffa::encoding::Tag::new(
5939 4u32,
5940 ::buffa::encoding::WireType::LengthDelimited,
5941 )
5942 .encode(buf);
5943 ::buffa::encoding::encode_varint(payload as u64, buf);
5944 for &v in &self.cover_columns {
5945 ::buffa::types::encode_uint32(v, buf);
5946 }
5947 }
5948 self.__buffa_unknown_fields.write_to(buf);
5949 }
5950 }
5951 impl<'__a> ::serde::Serialize for IndexView<'__a> {
5963 fn serialize<__S: ::serde::Serializer>(
5964 &self,
5965 __s: __S,
5966 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5967 use ::serde::ser::SerializeMap as _;
5968 let mut __map = __s.serialize_map(::core::option::Option::None)?;
5969 if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
5970 __map.serialize_entry("name", self.name)?;
5971 }
5972 if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.layout) {
5973 __map.serialize_entry("layout", &self.layout)?;
5974 }
5975 if !self.key_columns.is_empty() {
5976 struct _WSeq<'__x>(&'__x [u32]);
5977 impl ::serde::Serialize for _WSeq<'_> {
5978 fn serialize<__S: ::serde::Serializer>(
5979 &self,
5980 __s: __S,
5981 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5982 ::buffa::json_helpers::proto_seq::serialize(self.0, __s)
5983 }
5984 }
5985 __map.serialize_entry("keyColumns", &_WSeq(&self.key_columns))?;
5986 }
5987 if !self.cover_columns.is_empty() {
5988 struct _WSeq<'__x>(&'__x [u32]);
5989 impl ::serde::Serialize for _WSeq<'_> {
5990 fn serialize<__S: ::serde::Serializer>(
5991 &self,
5992 __s: __S,
5993 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5994 ::buffa::json_helpers::proto_seq::serialize(self.0, __s)
5995 }
5996 }
5997 __map.serialize_entry("coverColumns", &_WSeq(&self.cover_columns))?;
5998 }
5999 __map.end()
6000 }
6001 }
6002 impl<'a> ::buffa::MessageName for IndexView<'a> {
6003 const PACKAGE: &'static str = "sql.v1";
6004 const NAME: &'static str = "Index";
6005 const FULL_NAME: &'static str = "sql.v1.Index";
6006 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Index";
6007 }
6008 impl<'v> ::buffa::DefaultViewInstance for IndexView<'v> {
6009 fn default_view_instance<'a>() -> &'a Self
6010 where
6011 Self: 'a,
6012 {
6013 static VALUE: ::buffa::__private::OnceBox<IndexView<'static>> = ::buffa::__private::OnceBox::new();
6014 VALUE
6015 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6016 <IndexView<'static>>::default(),
6017 ))
6018 }
6019 }
6020 impl ::buffa::ViewReborrow for IndexView<'static> {
6021 type Reborrowed<'b> = IndexView<'b>;
6022 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
6023 this
6024 }
6025 }
6026 #[derive(Clone, Debug, Default)]
6028 pub struct QueryRequestView<'a> {
6029 pub sql: &'a str,
6031 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
6032 }
6033 impl<'a> QueryRequestView<'a> {
6034 #[doc(hidden)]
6042 pub fn _decode_depth(
6043 buf: &'a [u8],
6044 depth: u32,
6045 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6046 let mut view = Self::default();
6047 view._merge_into_view(buf, depth)?;
6048 ::core::result::Result::Ok(view)
6049 }
6050 #[doc(hidden)]
6058 pub fn _merge_into_view(
6059 &mut self,
6060 buf: &'a [u8],
6061 depth: u32,
6062 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6063 let _ = depth;
6064 #[allow(unused_variables)]
6065 let view = self;
6066 let mut cur: &'a [u8] = buf;
6067 while !cur.is_empty() {
6068 let before_tag = cur;
6069 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
6070 match tag.field_number() {
6071 1u32 => {
6072 if tag.wire_type()
6073 != ::buffa::encoding::WireType::LengthDelimited
6074 {
6075 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6076 field_number: 1u32,
6077 expected: 2u8,
6078 actual: tag.wire_type() as u8,
6079 });
6080 }
6081 view.sql = ::buffa::types::borrow_str(&mut cur)?;
6082 }
6083 _ => {
6084 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
6085 let span_len = before_tag.len() - cur.len();
6086 view.__buffa_unknown_fields
6087 .push_raw(&before_tag[..span_len]);
6088 }
6089 }
6090 }
6091 ::core::result::Result::Ok(())
6092 }
6093 }
6094 impl<'a> ::buffa::MessageView<'a> for QueryRequestView<'a> {
6095 type Owned = super::super::QueryRequest;
6096 fn decode_view(
6097 buf: &'a [u8],
6098 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6099 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
6100 }
6101 fn decode_view_with_limit(
6102 buf: &'a [u8],
6103 depth: u32,
6104 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6105 Self::_decode_depth(buf, depth)
6106 }
6107 fn to_owned_message(&self) -> super::super::QueryRequest {
6108 self.to_owned_from_source(None)
6109 }
6110 #[allow(clippy::useless_conversion, clippy::needless_update)]
6111 fn to_owned_from_source(
6112 &self,
6113 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
6114 ) -> super::super::QueryRequest {
6115 #[allow(unused_imports)]
6116 use ::buffa::alloc::string::ToString as _;
6117 let _ = __buffa_src;
6118 super::super::QueryRequest {
6119 sql: self.sql.to_string(),
6120 __buffa_unknown_fields: self
6121 .__buffa_unknown_fields
6122 .to_owned()
6123 .unwrap_or_default()
6124 .into(),
6125 ..::core::default::Default::default()
6126 }
6127 }
6128 }
6129 impl<'a> ::buffa::ViewEncode<'a> for QueryRequestView<'a> {
6130 #[allow(clippy::needless_borrow, clippy::let_and_return)]
6131 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
6132 #[allow(unused_imports)]
6133 use ::buffa::Enumeration as _;
6134 let mut size = 0u32;
6135 if !self.sql.is_empty() {
6136 size += 1u32 + ::buffa::types::string_encoded_len(&self.sql) as u32;
6137 }
6138 size += self.__buffa_unknown_fields.encoded_len() as u32;
6139 size
6140 }
6141 #[allow(clippy::needless_borrow)]
6142 fn write_to(
6143 &self,
6144 _cache: &mut ::buffa::SizeCache,
6145 buf: &mut impl ::buffa::bytes::BufMut,
6146 ) {
6147 #[allow(unused_imports)]
6148 use ::buffa::Enumeration as _;
6149 if !self.sql.is_empty() {
6150 ::buffa::encoding::Tag::new(
6151 1u32,
6152 ::buffa::encoding::WireType::LengthDelimited,
6153 )
6154 .encode(buf);
6155 ::buffa::types::encode_string(&self.sql, buf);
6156 }
6157 self.__buffa_unknown_fields.write_to(buf);
6158 }
6159 }
6160 impl<'__a> ::serde::Serialize for QueryRequestView<'__a> {
6172 fn serialize<__S: ::serde::Serializer>(
6173 &self,
6174 __s: __S,
6175 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6176 use ::serde::ser::SerializeMap as _;
6177 let mut __map = __s.serialize_map(::core::option::Option::None)?;
6178 if !::buffa::json_helpers::skip_if::is_empty_str(self.sql) {
6179 __map.serialize_entry("sql", self.sql)?;
6180 }
6181 __map.end()
6182 }
6183 }
6184 impl<'a> ::buffa::MessageName for QueryRequestView<'a> {
6185 const PACKAGE: &'static str = "sql.v1";
6186 const NAME: &'static str = "QueryRequest";
6187 const FULL_NAME: &'static str = "sql.v1.QueryRequest";
6188 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryRequest";
6189 }
6190 impl<'v> ::buffa::DefaultViewInstance for QueryRequestView<'v> {
6191 fn default_view_instance<'a>() -> &'a Self
6192 where
6193 Self: 'a,
6194 {
6195 static VALUE: ::buffa::__private::OnceBox<QueryRequestView<'static>> = ::buffa::__private::OnceBox::new();
6196 VALUE
6197 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6198 <QueryRequestView<'static>>::default(),
6199 ))
6200 }
6201 }
6202 impl ::buffa::ViewReborrow for QueryRequestView<'static> {
6203 type Reborrowed<'b> = QueryRequestView<'b>;
6204 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
6205 this
6206 }
6207 }
6208 #[derive(Clone, Debug, Default)]
6210 pub struct QueryResponseView<'a> {
6211 pub column: ::buffa::RepeatedView<'a, &'a str>,
6213 pub rows: ::buffa::RepeatedView<
6215 'a,
6216 super::super::__buffa::view::RowView<'a>,
6217 >,
6218 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
6219 }
6220 impl<'a> QueryResponseView<'a> {
6221 #[doc(hidden)]
6229 pub fn _decode_depth(
6230 buf: &'a [u8],
6231 depth: u32,
6232 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6233 let mut view = Self::default();
6234 view._merge_into_view(buf, depth)?;
6235 ::core::result::Result::Ok(view)
6236 }
6237 #[doc(hidden)]
6245 pub fn _merge_into_view(
6246 &mut self,
6247 buf: &'a [u8],
6248 depth: u32,
6249 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6250 let _ = depth;
6251 #[allow(unused_variables)]
6252 let view = self;
6253 let mut cur: &'a [u8] = buf;
6254 while !cur.is_empty() {
6255 let before_tag = cur;
6256 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
6257 match tag.field_number() {
6258 1u32 => {
6259 if tag.wire_type()
6260 != ::buffa::encoding::WireType::LengthDelimited
6261 {
6262 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6263 field_number: 1u32,
6264 expected: 2u8,
6265 actual: tag.wire_type() as u8,
6266 });
6267 }
6268 view.column.push(::buffa::types::borrow_str(&mut cur)?);
6269 }
6270 2u32 => {
6271 if tag.wire_type()
6272 != ::buffa::encoding::WireType::LengthDelimited
6273 {
6274 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6275 field_number: 2u32,
6276 expected: 2u8,
6277 actual: tag.wire_type() as u8,
6278 });
6279 }
6280 if depth == 0 {
6281 return Err(::buffa::DecodeError::RecursionLimitExceeded);
6282 }
6283 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
6284 view.rows
6285 .push(
6286 super::super::__buffa::view::RowView::_decode_depth(
6287 sub,
6288 depth - 1,
6289 )?,
6290 );
6291 }
6292 _ => {
6293 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
6294 let span_len = before_tag.len() - cur.len();
6295 view.__buffa_unknown_fields
6296 .push_raw(&before_tag[..span_len]);
6297 }
6298 }
6299 }
6300 ::core::result::Result::Ok(())
6301 }
6302 }
6303 impl<'a> ::buffa::MessageView<'a> for QueryResponseView<'a> {
6304 type Owned = super::super::QueryResponse;
6305 fn decode_view(
6306 buf: &'a [u8],
6307 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6308 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
6309 }
6310 fn decode_view_with_limit(
6311 buf: &'a [u8],
6312 depth: u32,
6313 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6314 Self::_decode_depth(buf, depth)
6315 }
6316 fn to_owned_message(&self) -> super::super::QueryResponse {
6317 self.to_owned_from_source(None)
6318 }
6319 #[allow(clippy::useless_conversion, clippy::needless_update)]
6320 fn to_owned_from_source(
6321 &self,
6322 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
6323 ) -> super::super::QueryResponse {
6324 #[allow(unused_imports)]
6325 use ::buffa::alloc::string::ToString as _;
6326 let _ = __buffa_src;
6327 super::super::QueryResponse {
6328 column: self.column.iter().map(|s| s.to_string()).collect(),
6329 rows: self
6330 .rows
6331 .iter()
6332 .map(|v| v.to_owned_from_source(__buffa_src))
6333 .collect(),
6334 __buffa_unknown_fields: self
6335 .__buffa_unknown_fields
6336 .to_owned()
6337 .unwrap_or_default()
6338 .into(),
6339 ..::core::default::Default::default()
6340 }
6341 }
6342 }
6343 impl<'a> ::buffa::ViewEncode<'a> for QueryResponseView<'a> {
6344 #[allow(clippy::needless_borrow, clippy::let_and_return)]
6345 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
6346 #[allow(unused_imports)]
6347 use ::buffa::Enumeration as _;
6348 let mut size = 0u32;
6349 for v in &self.column {
6350 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
6351 }
6352 for v in &self.rows {
6353 let __slot = __cache.reserve();
6354 let inner_size = v.compute_size(__cache);
6355 __cache.set(__slot, inner_size);
6356 size
6357 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
6358 + inner_size;
6359 }
6360 size += self.__buffa_unknown_fields.encoded_len() as u32;
6361 size
6362 }
6363 #[allow(clippy::needless_borrow)]
6364 fn write_to(
6365 &self,
6366 __cache: &mut ::buffa::SizeCache,
6367 buf: &mut impl ::buffa::bytes::BufMut,
6368 ) {
6369 #[allow(unused_imports)]
6370 use ::buffa::Enumeration as _;
6371 for v in &self.column {
6372 ::buffa::encoding::Tag::new(
6373 1u32,
6374 ::buffa::encoding::WireType::LengthDelimited,
6375 )
6376 .encode(buf);
6377 ::buffa::types::encode_string(v, buf);
6378 }
6379 for v in &self.rows {
6380 ::buffa::encoding::Tag::new(
6381 2u32,
6382 ::buffa::encoding::WireType::LengthDelimited,
6383 )
6384 .encode(buf);
6385 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
6386 v.write_to(__cache, buf);
6387 }
6388 self.__buffa_unknown_fields.write_to(buf);
6389 }
6390 }
6391 impl<'__a> ::serde::Serialize for QueryResponseView<'__a> {
6403 fn serialize<__S: ::serde::Serializer>(
6404 &self,
6405 __s: __S,
6406 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6407 use ::serde::ser::SerializeMap as _;
6408 let mut __map = __s.serialize_map(::core::option::Option::None)?;
6409 if !self.column.is_empty() {
6410 __map.serialize_entry("column", &*self.column)?;
6411 }
6412 if !self.rows.is_empty() {
6413 __map.serialize_entry("rows", &*self.rows)?;
6414 }
6415 __map.end()
6416 }
6417 }
6418 impl<'a> ::buffa::MessageName for QueryResponseView<'a> {
6419 const PACKAGE: &'static str = "sql.v1";
6420 const NAME: &'static str = "QueryResponse";
6421 const FULL_NAME: &'static str = "sql.v1.QueryResponse";
6422 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryResponse";
6423 }
6424 impl<'v> ::buffa::DefaultViewInstance for QueryResponseView<'v> {
6425 fn default_view_instance<'a>() -> &'a Self
6426 where
6427 Self: 'a,
6428 {
6429 static VALUE: ::buffa::__private::OnceBox<QueryResponseView<'static>> = ::buffa::__private::OnceBox::new();
6430 VALUE
6431 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6432 <QueryResponseView<'static>>::default(),
6433 ))
6434 }
6435 }
6436 impl ::buffa::ViewReborrow for QueryResponseView<'static> {
6437 type Reborrowed<'b> = QueryResponseView<'b>;
6438 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
6439 this
6440 }
6441 }
6442 #[derive(Clone, Debug, Default)]
6444 pub struct SubscribeRequestView<'a> {
6445 pub table: &'a str,
6449 pub where_sql: &'a str,
6455 pub since_sequence_number: ::core::option::Option<u64>,
6460 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
6461 }
6462 impl<'a> SubscribeRequestView<'a> {
6463 #[doc(hidden)]
6471 pub fn _decode_depth(
6472 buf: &'a [u8],
6473 depth: u32,
6474 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6475 let mut view = Self::default();
6476 view._merge_into_view(buf, depth)?;
6477 ::core::result::Result::Ok(view)
6478 }
6479 #[doc(hidden)]
6487 pub fn _merge_into_view(
6488 &mut self,
6489 buf: &'a [u8],
6490 depth: u32,
6491 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6492 let _ = depth;
6493 #[allow(unused_variables)]
6494 let view = self;
6495 let mut cur: &'a [u8] = buf;
6496 while !cur.is_empty() {
6497 let before_tag = cur;
6498 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
6499 match tag.field_number() {
6500 1u32 => {
6501 if tag.wire_type()
6502 != ::buffa::encoding::WireType::LengthDelimited
6503 {
6504 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6505 field_number: 1u32,
6506 expected: 2u8,
6507 actual: tag.wire_type() as u8,
6508 });
6509 }
6510 view.table = ::buffa::types::borrow_str(&mut cur)?;
6511 }
6512 2u32 => {
6513 if tag.wire_type()
6514 != ::buffa::encoding::WireType::LengthDelimited
6515 {
6516 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6517 field_number: 2u32,
6518 expected: 2u8,
6519 actual: tag.wire_type() as u8,
6520 });
6521 }
6522 view.where_sql = ::buffa::types::borrow_str(&mut cur)?;
6523 }
6524 3u32 => {
6525 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6526 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6527 field_number: 3u32,
6528 expected: 0u8,
6529 actual: tag.wire_type() as u8,
6530 });
6531 }
6532 view.since_sequence_number = Some(
6533 ::buffa::types::decode_uint64(&mut cur)?,
6534 );
6535 }
6536 _ => {
6537 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
6538 let span_len = before_tag.len() - cur.len();
6539 view.__buffa_unknown_fields
6540 .push_raw(&before_tag[..span_len]);
6541 }
6542 }
6543 }
6544 ::core::result::Result::Ok(())
6545 }
6546 }
6547 impl<'a> ::buffa::MessageView<'a> for SubscribeRequestView<'a> {
6548 type Owned = super::super::SubscribeRequest;
6549 fn decode_view(
6550 buf: &'a [u8],
6551 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6552 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
6553 }
6554 fn decode_view_with_limit(
6555 buf: &'a [u8],
6556 depth: u32,
6557 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6558 Self::_decode_depth(buf, depth)
6559 }
6560 fn to_owned_message(&self) -> super::super::SubscribeRequest {
6561 self.to_owned_from_source(None)
6562 }
6563 #[allow(clippy::useless_conversion, clippy::needless_update)]
6564 fn to_owned_from_source(
6565 &self,
6566 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
6567 ) -> super::super::SubscribeRequest {
6568 #[allow(unused_imports)]
6569 use ::buffa::alloc::string::ToString as _;
6570 let _ = __buffa_src;
6571 super::super::SubscribeRequest {
6572 table: self.table.to_string(),
6573 where_sql: self.where_sql.to_string(),
6574 since_sequence_number: self.since_sequence_number,
6575 __buffa_unknown_fields: self
6576 .__buffa_unknown_fields
6577 .to_owned()
6578 .unwrap_or_default()
6579 .into(),
6580 ..::core::default::Default::default()
6581 }
6582 }
6583 }
6584 impl<'a> ::buffa::ViewEncode<'a> for SubscribeRequestView<'a> {
6585 #[allow(clippy::needless_borrow, clippy::let_and_return)]
6586 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
6587 #[allow(unused_imports)]
6588 use ::buffa::Enumeration as _;
6589 let mut size = 0u32;
6590 if !self.table.is_empty() {
6591 size
6592 += 1u32 + ::buffa::types::string_encoded_len(&self.table) as u32;
6593 }
6594 if !self.where_sql.is_empty() {
6595 size
6596 += 1u32
6597 + ::buffa::types::string_encoded_len(&self.where_sql) as u32;
6598 }
6599 if let Some(v) = self.since_sequence_number {
6600 size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
6601 }
6602 size += self.__buffa_unknown_fields.encoded_len() as u32;
6603 size
6604 }
6605 #[allow(clippy::needless_borrow)]
6606 fn write_to(
6607 &self,
6608 _cache: &mut ::buffa::SizeCache,
6609 buf: &mut impl ::buffa::bytes::BufMut,
6610 ) {
6611 #[allow(unused_imports)]
6612 use ::buffa::Enumeration as _;
6613 if !self.table.is_empty() {
6614 ::buffa::encoding::Tag::new(
6615 1u32,
6616 ::buffa::encoding::WireType::LengthDelimited,
6617 )
6618 .encode(buf);
6619 ::buffa::types::encode_string(&self.table, buf);
6620 }
6621 if !self.where_sql.is_empty() {
6622 ::buffa::encoding::Tag::new(
6623 2u32,
6624 ::buffa::encoding::WireType::LengthDelimited,
6625 )
6626 .encode(buf);
6627 ::buffa::types::encode_string(&self.where_sql, buf);
6628 }
6629 if let Some(v) = self.since_sequence_number {
6630 ::buffa::encoding::Tag::new(
6631 3u32,
6632 ::buffa::encoding::WireType::Varint,
6633 )
6634 .encode(buf);
6635 ::buffa::types::encode_uint64(v, buf);
6636 }
6637 self.__buffa_unknown_fields.write_to(buf);
6638 }
6639 }
6640 impl<'__a> ::serde::Serialize for SubscribeRequestView<'__a> {
6652 fn serialize<__S: ::serde::Serializer>(
6653 &self,
6654 __s: __S,
6655 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6656 use ::serde::ser::SerializeMap as _;
6657 let mut __map = __s.serialize_map(::core::option::Option::None)?;
6658 if !::buffa::json_helpers::skip_if::is_empty_str(self.table) {
6659 __map.serialize_entry("table", self.table)?;
6660 }
6661 if !::buffa::json_helpers::skip_if::is_empty_str(self.where_sql) {
6662 __map.serialize_entry("whereSql", self.where_sql)?;
6663 }
6664 if let ::core::option::Option::Some(__v) = self.since_sequence_number {
6665 struct _W(u64);
6666 impl ::serde::Serialize for _W {
6667 fn serialize<__S: ::serde::Serializer>(
6668 &self,
6669 __s: __S,
6670 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6671 ::buffa::json_helpers::uint64::serialize(&self.0, __s)
6672 }
6673 }
6674 __map.serialize_entry("sinceSequenceNumber", &_W(__v))?;
6675 }
6676 __map.end()
6677 }
6678 }
6679 impl<'a> ::buffa::MessageName for SubscribeRequestView<'a> {
6680 const PACKAGE: &'static str = "sql.v1";
6681 const NAME: &'static str = "SubscribeRequest";
6682 const FULL_NAME: &'static str = "sql.v1.SubscribeRequest";
6683 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeRequest";
6684 }
6685 impl<'v> ::buffa::DefaultViewInstance for SubscribeRequestView<'v> {
6686 fn default_view_instance<'a>() -> &'a Self
6687 where
6688 Self: 'a,
6689 {
6690 static VALUE: ::buffa::__private::OnceBox<
6691 SubscribeRequestView<'static>,
6692 > = ::buffa::__private::OnceBox::new();
6693 VALUE
6694 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6695 <SubscribeRequestView<'static>>::default(),
6696 ))
6697 }
6698 }
6699 impl ::buffa::ViewReborrow for SubscribeRequestView<'static> {
6700 type Reborrowed<'b> = SubscribeRequestView<'b>;
6701 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
6702 this
6703 }
6704 }
6705 #[derive(Clone, Debug, Default)]
6707 pub struct SubscribeResponseView<'a> {
6708 pub sequence_number: u64,
6713 pub column: ::buffa::RepeatedView<'a, &'a str>,
6717 pub rows: ::buffa::RepeatedView<
6722 'a,
6723 super::super::__buffa::view::RowView<'a>,
6724 >,
6725 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
6726 }
6727 impl<'a> SubscribeResponseView<'a> {
6728 #[doc(hidden)]
6736 pub fn _decode_depth(
6737 buf: &'a [u8],
6738 depth: u32,
6739 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6740 let mut view = Self::default();
6741 view._merge_into_view(buf, depth)?;
6742 ::core::result::Result::Ok(view)
6743 }
6744 #[doc(hidden)]
6752 pub fn _merge_into_view(
6753 &mut self,
6754 buf: &'a [u8],
6755 depth: u32,
6756 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6757 let _ = depth;
6758 #[allow(unused_variables)]
6759 let view = self;
6760 let mut cur: &'a [u8] = buf;
6761 while !cur.is_empty() {
6762 let before_tag = cur;
6763 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
6764 match tag.field_number() {
6765 1u32 => {
6766 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6767 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6768 field_number: 1u32,
6769 expected: 0u8,
6770 actual: tag.wire_type() as u8,
6771 });
6772 }
6773 view.sequence_number = ::buffa::types::decode_uint64(
6774 &mut cur,
6775 )?;
6776 }
6777 2u32 => {
6778 if tag.wire_type()
6779 != ::buffa::encoding::WireType::LengthDelimited
6780 {
6781 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6782 field_number: 2u32,
6783 expected: 2u8,
6784 actual: tag.wire_type() as u8,
6785 });
6786 }
6787 view.column.push(::buffa::types::borrow_str(&mut cur)?);
6788 }
6789 3u32 => {
6790 if tag.wire_type()
6791 != ::buffa::encoding::WireType::LengthDelimited
6792 {
6793 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6794 field_number: 3u32,
6795 expected: 2u8,
6796 actual: tag.wire_type() as u8,
6797 });
6798 }
6799 if depth == 0 {
6800 return Err(::buffa::DecodeError::RecursionLimitExceeded);
6801 }
6802 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
6803 view.rows
6804 .push(
6805 super::super::__buffa::view::RowView::_decode_depth(
6806 sub,
6807 depth - 1,
6808 )?,
6809 );
6810 }
6811 _ => {
6812 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
6813 let span_len = before_tag.len() - cur.len();
6814 view.__buffa_unknown_fields
6815 .push_raw(&before_tag[..span_len]);
6816 }
6817 }
6818 }
6819 ::core::result::Result::Ok(())
6820 }
6821 }
6822 impl<'a> ::buffa::MessageView<'a> for SubscribeResponseView<'a> {
6823 type Owned = super::super::SubscribeResponse;
6824 fn decode_view(
6825 buf: &'a [u8],
6826 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6827 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
6828 }
6829 fn decode_view_with_limit(
6830 buf: &'a [u8],
6831 depth: u32,
6832 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6833 Self::_decode_depth(buf, depth)
6834 }
6835 fn to_owned_message(&self) -> super::super::SubscribeResponse {
6836 self.to_owned_from_source(None)
6837 }
6838 #[allow(clippy::useless_conversion, clippy::needless_update)]
6839 fn to_owned_from_source(
6840 &self,
6841 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
6842 ) -> super::super::SubscribeResponse {
6843 #[allow(unused_imports)]
6844 use ::buffa::alloc::string::ToString as _;
6845 let _ = __buffa_src;
6846 super::super::SubscribeResponse {
6847 sequence_number: self.sequence_number,
6848 column: self.column.iter().map(|s| s.to_string()).collect(),
6849 rows: self
6850 .rows
6851 .iter()
6852 .map(|v| v.to_owned_from_source(__buffa_src))
6853 .collect(),
6854 __buffa_unknown_fields: self
6855 .__buffa_unknown_fields
6856 .to_owned()
6857 .unwrap_or_default()
6858 .into(),
6859 ..::core::default::Default::default()
6860 }
6861 }
6862 }
6863 impl<'a> ::buffa::ViewEncode<'a> for SubscribeResponseView<'a> {
6864 #[allow(clippy::needless_borrow, clippy::let_and_return)]
6865 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
6866 #[allow(unused_imports)]
6867 use ::buffa::Enumeration as _;
6868 let mut size = 0u32;
6869 if self.sequence_number != 0u64 {
6870 size
6871 += 1u32
6872 + ::buffa::types::uint64_encoded_len(self.sequence_number)
6873 as u32;
6874 }
6875 for v in &self.column {
6876 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
6877 }
6878 for v in &self.rows {
6879 let __slot = __cache.reserve();
6880 let inner_size = v.compute_size(__cache);
6881 __cache.set(__slot, inner_size);
6882 size
6883 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
6884 + inner_size;
6885 }
6886 size += self.__buffa_unknown_fields.encoded_len() as u32;
6887 size
6888 }
6889 #[allow(clippy::needless_borrow)]
6890 fn write_to(
6891 &self,
6892 __cache: &mut ::buffa::SizeCache,
6893 buf: &mut impl ::buffa::bytes::BufMut,
6894 ) {
6895 #[allow(unused_imports)]
6896 use ::buffa::Enumeration as _;
6897 if self.sequence_number != 0u64 {
6898 ::buffa::encoding::Tag::new(
6899 1u32,
6900 ::buffa::encoding::WireType::Varint,
6901 )
6902 .encode(buf);
6903 ::buffa::types::encode_uint64(self.sequence_number, buf);
6904 }
6905 for v in &self.column {
6906 ::buffa::encoding::Tag::new(
6907 2u32,
6908 ::buffa::encoding::WireType::LengthDelimited,
6909 )
6910 .encode(buf);
6911 ::buffa::types::encode_string(v, buf);
6912 }
6913 for v in &self.rows {
6914 ::buffa::encoding::Tag::new(
6915 3u32,
6916 ::buffa::encoding::WireType::LengthDelimited,
6917 )
6918 .encode(buf);
6919 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
6920 v.write_to(__cache, buf);
6921 }
6922 self.__buffa_unknown_fields.write_to(buf);
6923 }
6924 }
6925 impl<'__a> ::serde::Serialize for SubscribeResponseView<'__a> {
6937 fn serialize<__S: ::serde::Serializer>(
6938 &self,
6939 __s: __S,
6940 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6941 use ::serde::ser::SerializeMap as _;
6942 let mut __map = __s.serialize_map(::core::option::Option::None)?;
6943 if !::buffa::json_helpers::skip_if::is_zero_u64(&self.sequence_number) {
6944 struct _W(u64);
6945 impl ::serde::Serialize for _W {
6946 fn serialize<__S: ::serde::Serializer>(
6947 &self,
6948 __s: __S,
6949 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6950 ::buffa::json_helpers::uint64::serialize(&self.0, __s)
6951 }
6952 }
6953 __map.serialize_entry("sequenceNumber", &_W(self.sequence_number))?;
6954 }
6955 if !self.column.is_empty() {
6956 __map.serialize_entry("column", &*self.column)?;
6957 }
6958 if !self.rows.is_empty() {
6959 __map.serialize_entry("rows", &*self.rows)?;
6960 }
6961 __map.end()
6962 }
6963 }
6964 impl<'a> ::buffa::MessageName for SubscribeResponseView<'a> {
6965 const PACKAGE: &'static str = "sql.v1";
6966 const NAME: &'static str = "SubscribeResponse";
6967 const FULL_NAME: &'static str = "sql.v1.SubscribeResponse";
6968 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeResponse";
6969 }
6970 impl<'v> ::buffa::DefaultViewInstance for SubscribeResponseView<'v> {
6971 fn default_view_instance<'a>() -> &'a Self
6972 where
6973 Self: 'a,
6974 {
6975 static VALUE: ::buffa::__private::OnceBox<
6976 SubscribeResponseView<'static>,
6977 > = ::buffa::__private::OnceBox::new();
6978 VALUE
6979 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6980 <SubscribeResponseView<'static>>::default(),
6981 ))
6982 }
6983 }
6984 impl ::buffa::ViewReborrow for SubscribeResponseView<'static> {
6985 type Reborrowed<'b> = SubscribeResponseView<'b>;
6986 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
6987 this
6988 }
6989 }
6990 pub mod oneof {
6991 #[allow(unused_imports)]
6992 use super::*;
6993 pub mod cell {
6994 #[allow(unused_imports)]
6995 use super::*;
6996 #[derive(Clone, Debug)]
6997 pub enum Kind<'a> {
6998 NullValue(
6999 ::buffa::alloc::boxed::Box<
7000 super::super::super::super::__buffa::view::NullView<'a>,
7001 >,
7002 ),
7003 Int64Value(i64),
7004 Uint64Value(u64),
7005 Float64Value(f64),
7006 BooleanValue(bool),
7007 Utf8Value(&'a str),
7008 FixedSizeBinaryValue(&'a [u8]),
7009 Date32Value(i32),
7010 Date64Value(i64),
7011 TimestampValue(i64),
7012 Decimal128Value(&'a [u8]),
7013 Decimal256Value(&'a [u8]),
7014 ListValue(
7015 ::buffa::alloc::boxed::Box<
7016 super::super::super::super::__buffa::view::ListValueView<'a>,
7017 >,
7018 ),
7019 BinaryValue(&'a [u8]),
7020 }
7021 }
7022 }
7023 }
7024 pub mod oneof {
7025 #[allow(unused_imports)]
7026 use super::*;
7027 pub mod cell {
7028 #[allow(unused_imports)]
7029 use super::*;
7030 #[derive(Clone, PartialEq, Debug)]
7031 pub enum Kind {
7032 NullValue(::buffa::alloc::boxed::Box<super::super::super::Null>),
7033 Int64Value(i64),
7034 Uint64Value(u64),
7035 Float64Value(f64),
7036 BooleanValue(bool),
7037 Utf8Value(::buffa::alloc::string::String),
7038 FixedSizeBinaryValue(::buffa::bytes::Bytes),
7039 Date32Value(i32),
7040 Date64Value(i64),
7041 TimestampValue(i64),
7042 Decimal128Value(::buffa::bytes::Bytes),
7043 Decimal256Value(::buffa::bytes::Bytes),
7044 ListValue(::buffa::alloc::boxed::Box<super::super::super::ListValue>),
7045 BinaryValue(::buffa::bytes::Bytes),
7046 }
7047 impl ::buffa::Oneof for Kind {}
7048 impl From<super::super::super::Null> for Kind {
7049 fn from(v: super::super::super::Null) -> Self {
7050 Self::NullValue(::buffa::alloc::boxed::Box::new(v))
7051 }
7052 }
7053 impl From<super::super::super::Null> for ::core::option::Option<Kind> {
7054 fn from(v: super::super::super::Null) -> Self {
7055 Self::Some(Kind::from(v))
7056 }
7057 }
7058 impl From<super::super::super::ListValue> for Kind {
7059 fn from(v: super::super::super::ListValue) -> Self {
7060 Self::ListValue(::buffa::alloc::boxed::Box::new(v))
7061 }
7062 }
7063 impl From<super::super::super::ListValue> for ::core::option::Option<Kind> {
7064 fn from(v: super::super::super::ListValue) -> Self {
7065 Self::Some(Kind::from(v))
7066 }
7067 }
7068 impl serde::Serialize for Kind {
7069 fn serialize<S: serde::Serializer>(
7070 &self,
7071 s: S,
7072 ) -> ::core::result::Result<S::Ok, S::Error> {
7073 use serde::ser::SerializeMap;
7074 let mut map = s.serialize_map(Some(1))?;
7075 match self {
7076 Self::NullValue(v) => {
7077 map.serialize_entry("nullValue", v)?;
7078 }
7079 Self::Int64Value(v) => {
7080 struct _W<'a>(&'a i64);
7081 impl serde::Serialize for _W<'_> {
7082 fn serialize<S2: serde::Serializer>(
7083 &self,
7084 s: S2,
7085 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7086 ::buffa::json_helpers::int64::serialize(self.0, s)
7087 }
7088 }
7089 map.serialize_entry("int64Value", &_W(v))?;
7090 }
7091 Self::Uint64Value(v) => {
7092 struct _W<'a>(&'a u64);
7093 impl serde::Serialize for _W<'_> {
7094 fn serialize<S2: serde::Serializer>(
7095 &self,
7096 s: S2,
7097 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7098 ::buffa::json_helpers::uint64::serialize(self.0, s)
7099 }
7100 }
7101 map.serialize_entry("uint64Value", &_W(v))?;
7102 }
7103 Self::Float64Value(v) => {
7104 struct _W<'a>(&'a f64);
7105 impl serde::Serialize for _W<'_> {
7106 fn serialize<S2: serde::Serializer>(
7107 &self,
7108 s: S2,
7109 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7110 ::buffa::json_helpers::double::serialize(self.0, s)
7111 }
7112 }
7113 map.serialize_entry("float64Value", &_W(v))?;
7114 }
7115 Self::BooleanValue(v) => {
7116 map.serialize_entry("booleanValue", v)?;
7117 }
7118 Self::Utf8Value(v) => {
7119 map.serialize_entry("utf8Value", v)?;
7120 }
7121 Self::FixedSizeBinaryValue(v) => {
7122 struct _W<'a>(&'a ::buffa::bytes::Bytes);
7123 impl serde::Serialize for _W<'_> {
7124 fn serialize<S2: serde::Serializer>(
7125 &self,
7126 s: S2,
7127 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7128 ::buffa::json_helpers::bytes::serialize(self.0, s)
7129 }
7130 }
7131 map.serialize_entry("fixedSizeBinaryValue", &_W(v))?;
7132 }
7133 Self::Date32Value(v) => {
7134 struct _W<'a>(&'a i32);
7135 impl serde::Serialize for _W<'_> {
7136 fn serialize<S2: serde::Serializer>(
7137 &self,
7138 s: S2,
7139 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7140 ::buffa::json_helpers::int32::serialize(self.0, s)
7141 }
7142 }
7143 map.serialize_entry("date32Value", &_W(v))?;
7144 }
7145 Self::Date64Value(v) => {
7146 struct _W<'a>(&'a i64);
7147 impl serde::Serialize for _W<'_> {
7148 fn serialize<S2: serde::Serializer>(
7149 &self,
7150 s: S2,
7151 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7152 ::buffa::json_helpers::int64::serialize(self.0, s)
7153 }
7154 }
7155 map.serialize_entry("date64Value", &_W(v))?;
7156 }
7157 Self::TimestampValue(v) => {
7158 struct _W<'a>(&'a i64);
7159 impl serde::Serialize for _W<'_> {
7160 fn serialize<S2: serde::Serializer>(
7161 &self,
7162 s: S2,
7163 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7164 ::buffa::json_helpers::int64::serialize(self.0, s)
7165 }
7166 }
7167 map.serialize_entry("timestampValue", &_W(v))?;
7168 }
7169 Self::Decimal128Value(v) => {
7170 struct _W<'a>(&'a ::buffa::bytes::Bytes);
7171 impl serde::Serialize for _W<'_> {
7172 fn serialize<S2: serde::Serializer>(
7173 &self,
7174 s: S2,
7175 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7176 ::buffa::json_helpers::bytes::serialize(self.0, s)
7177 }
7178 }
7179 map.serialize_entry("decimal128Value", &_W(v))?;
7180 }
7181 Self::Decimal256Value(v) => {
7182 struct _W<'a>(&'a ::buffa::bytes::Bytes);
7183 impl serde::Serialize for _W<'_> {
7184 fn serialize<S2: serde::Serializer>(
7185 &self,
7186 s: S2,
7187 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7188 ::buffa::json_helpers::bytes::serialize(self.0, s)
7189 }
7190 }
7191 map.serialize_entry("decimal256Value", &_W(v))?;
7192 }
7193 Self::ListValue(v) => {
7194 map.serialize_entry("listValue", v)?;
7195 }
7196 Self::BinaryValue(v) => {
7197 struct _W<'a>(&'a ::buffa::bytes::Bytes);
7198 impl serde::Serialize for _W<'_> {
7199 fn serialize<S2: serde::Serializer>(
7200 &self,
7201 s: S2,
7202 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7203 ::buffa::json_helpers::bytes::serialize(self.0, s)
7204 }
7205 }
7206 map.serialize_entry("binaryValue", &_W(v))?;
7207 }
7208 }
7209 map.end()
7210 }
7211 }
7212 }
7213 }
7214}
7215#[doc(inline)]
7216pub use self::__buffa::view::RowView;
7217#[doc(inline)]
7218pub use self::__buffa::view::NullView;
7219#[doc(inline)]
7220pub use self::__buffa::view::ListValueView;
7221#[doc(inline)]
7222pub use self::__buffa::view::CellView;
7223#[doc(inline)]
7224pub use self::__buffa::view::TablesResponseView;
7225#[doc(inline)]
7226pub use self::__buffa::view::TablesRequestView;
7227#[doc(inline)]
7228pub use self::__buffa::view::TableView;
7229#[doc(inline)]
7230pub use self::__buffa::view::ColumnView;
7231#[doc(inline)]
7232pub use self::__buffa::view::IndexView;
7233#[doc(inline)]
7234pub use self::__buffa::view::QueryRequestView;
7235#[doc(inline)]
7236pub use self::__buffa::view::QueryResponseView;
7237#[doc(inline)]
7238pub use self::__buffa::view::SubscribeRequestView;
7239#[doc(inline)]
7240pub use self::__buffa::view::SubscribeResponseView;
7241
7242pub type OwnedSubscribeRequestView = ::buffa::view::OwnedView<
7244 __buffa::view::SubscribeRequestView<'static>,
7245>;
7246pub type OwnedSubscribeResponseView = ::buffa::view::OwnedView<
7248 __buffa::view::SubscribeResponseView<'static>,
7249>;
7250pub type OwnedQueryRequestView = ::buffa::view::OwnedView<
7252 __buffa::view::QueryRequestView<'static>,
7253>;
7254pub type OwnedQueryResponseView = ::buffa::view::OwnedView<
7256 __buffa::view::QueryResponseView<'static>,
7257>;
7258pub type OwnedTablesRequestView = ::buffa::view::OwnedView<
7260 __buffa::view::TablesRequestView<'static>,
7261>;
7262pub type OwnedTablesResponseView = ::buffa::view::OwnedView<
7264 __buffa::view::TablesResponseView<'static>,
7265>;
7266impl ::connectrpc::Encodable<SubscribeResponse>
7267for __buffa::view::SubscribeResponseView<'_> {
7268 fn encode(
7269 &self,
7270 codec: ::connectrpc::CodecFormat,
7271 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7272 ::connectrpc::__codegen::encode_view_body(self, codec)
7273 }
7274}
7275impl ::connectrpc::Encodable<SubscribeResponse>
7276for ::buffa::view::OwnedView<__buffa::view::SubscribeResponseView<'static>> {
7277 fn encode(
7278 &self,
7279 codec: ::connectrpc::CodecFormat,
7280 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7281 ::connectrpc::__codegen::encode_view_body(&**self, codec)
7282 }
7283}
7284impl ::connectrpc::Encodable<QueryResponse> for __buffa::view::QueryResponseView<'_> {
7285 fn encode(
7286 &self,
7287 codec: ::connectrpc::CodecFormat,
7288 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7289 ::connectrpc::__codegen::encode_view_body(self, codec)
7290 }
7291}
7292impl ::connectrpc::Encodable<QueryResponse>
7293for ::buffa::view::OwnedView<__buffa::view::QueryResponseView<'static>> {
7294 fn encode(
7295 &self,
7296 codec: ::connectrpc::CodecFormat,
7297 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7298 ::connectrpc::__codegen::encode_view_body(&**self, codec)
7299 }
7300}
7301impl ::connectrpc::Encodable<TablesResponse> for __buffa::view::TablesResponseView<'_> {
7302 fn encode(
7303 &self,
7304 codec: ::connectrpc::CodecFormat,
7305 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7306 ::connectrpc::__codegen::encode_view_body(self, codec)
7307 }
7308}
7309impl ::connectrpc::Encodable<TablesResponse>
7310for ::buffa::view::OwnedView<__buffa::view::TablesResponseView<'static>> {
7311 fn encode(
7312 &self,
7313 codec: ::connectrpc::CodecFormat,
7314 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7315 ::connectrpc::__codegen::encode_view_body(&**self, codec)
7316 }
7317}
7318pub const SERVICE_SERVICE_NAME: &str = "sql.v1.Service";
7320pub const SERVICE_SUBSCRIBE_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
7325 "/sql.v1.Service/Subscribe",
7326 ::connectrpc::StreamType::ServerStream,
7327 )
7328 .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
7329pub const SERVICE_QUERY_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
7334 "/sql.v1.Service/Query",
7335 ::connectrpc::StreamType::Unary,
7336 )
7337 .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
7338pub const SERVICE_TABLES_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
7343 "/sql.v1.Service/Tables",
7344 ::connectrpc::StreamType::Unary,
7345 )
7346 .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
7347#[allow(clippy::type_complexity)]
7385pub trait Service: Send + Sync + 'static {
7386 fn subscribe(
7390 &self,
7391 ctx: ::connectrpc::RequestContext,
7392 request: OwnedSubscribeRequestView,
7393 ) -> impl ::std::future::Future<
7394 Output = ::connectrpc::ServiceResult<
7395 ::connectrpc::ServiceStream<
7396 impl ::connectrpc::Encodable<SubscribeResponse> + Send + use<Self>,
7397 >,
7398 >,
7399 > + Send;
7400 fn query<'a>(
7405 &'a self,
7406 ctx: ::connectrpc::RequestContext,
7407 request: OwnedQueryRequestView,
7408 ) -> impl ::std::future::Future<
7409 Output = ::connectrpc::ServiceResult<
7410 impl ::connectrpc::Encodable<QueryResponse> + Send + use<'a, Self>,
7411 >,
7412 > + Send;
7413 fn tables<'a>(
7419 &'a self,
7420 ctx: ::connectrpc::RequestContext,
7421 request: OwnedTablesRequestView,
7422 ) -> impl ::std::future::Future<
7423 Output = ::connectrpc::ServiceResult<
7424 impl ::connectrpc::Encodable<TablesResponse> + Send + use<'a, Self>,
7425 >,
7426 > + Send;
7427}
7428pub trait ServiceExt: Service {
7441 fn register(
7446 self: ::std::sync::Arc<Self>,
7447 router: ::connectrpc::Router,
7448 ) -> ::connectrpc::Router;
7449}
7450impl<S: Service> ServiceExt for S {
7451 fn register(
7452 self: ::std::sync::Arc<Self>,
7453 router: ::connectrpc::Router,
7454 ) -> ::connectrpc::Router {
7455 router
7456 .route_view_server_stream::<
7457 _,
7458 _,
7459 SubscribeResponse,
7460 >(
7461 SERVICE_SERVICE_NAME,
7462 "Subscribe",
7463 ::connectrpc::view_streaming_handler_fn({
7464 let svc = ::std::sync::Arc::clone(&self);
7465 move |ctx, req| {
7466 let svc = ::std::sync::Arc::clone(&svc);
7467 async move { svc.subscribe(ctx, req).await }
7468 }
7469 }),
7470 )
7471 .with_spec(SERVICE_SUBSCRIBE_SPEC)
7472 .route_view(
7473 SERVICE_SERVICE_NAME,
7474 "Query",
7475 {
7476 let svc = ::std::sync::Arc::clone(&self);
7477 ::connectrpc::view_handler_fn(move |ctx, req, format| {
7478 let svc = ::std::sync::Arc::clone(&svc);
7479 async move {
7480 svc.query(ctx, req).await?.encode::<QueryResponse>(format)
7481 }
7482 })
7483 },
7484 )
7485 .with_spec(SERVICE_QUERY_SPEC)
7486 .route_view(
7487 SERVICE_SERVICE_NAME,
7488 "Tables",
7489 {
7490 let svc = ::std::sync::Arc::clone(&self);
7491 ::connectrpc::view_handler_fn(move |ctx, req, format| {
7492 let svc = ::std::sync::Arc::clone(&svc);
7493 async move {
7494 svc.tables(ctx, req).await?.encode::<TablesResponse>(format)
7495 }
7496 })
7497 },
7498 )
7499 .with_spec(SERVICE_TABLES_SPEC)
7500 }
7501}
7502pub struct ServiceServer<T> {
7516 inner: ::std::sync::Arc<T>,
7517}
7518impl<T: Service> ServiceServer<T> {
7519 pub fn new(service: T) -> Self {
7521 Self {
7522 inner: ::std::sync::Arc::new(service),
7523 }
7524 }
7525 pub fn from_arc(inner: ::std::sync::Arc<T>) -> Self {
7527 Self { inner }
7528 }
7529}
7530impl<T> Clone for ServiceServer<T> {
7531 fn clone(&self) -> Self {
7532 Self {
7533 inner: ::std::sync::Arc::clone(&self.inner),
7534 }
7535 }
7536}
7537impl<T: Service> ::connectrpc::Dispatcher for ServiceServer<T> {
7538 #[inline]
7539 fn lookup(
7540 &self,
7541 path: &str,
7542 ) -> Option<::connectrpc::dispatcher::codegen::MethodDescriptor> {
7543 let method = path.strip_prefix("sql.v1.Service/")?;
7544 match method {
7545 "Subscribe" => {
7546 Some(
7547 ::connectrpc::dispatcher::codegen::MethodDescriptor::server_streaming()
7548 .with_spec(SERVICE_SUBSCRIBE_SPEC),
7549 )
7550 }
7551 "Query" => {
7552 Some(
7553 ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
7554 .with_spec(SERVICE_QUERY_SPEC),
7555 )
7556 }
7557 "Tables" => {
7558 Some(
7559 ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
7560 .with_spec(SERVICE_TABLES_SPEC),
7561 )
7562 }
7563 _ => None,
7564 }
7565 }
7566 fn call_unary(
7567 &self,
7568 path: &str,
7569 ctx: ::connectrpc::RequestContext,
7570 request: ::connectrpc::Payload,
7571 format: ::connectrpc::CodecFormat,
7572 ) -> ::connectrpc::dispatcher::codegen::UnaryResult {
7573 let Some(method) = path.strip_prefix("sql.v1.Service/") else {
7574 return ::connectrpc::dispatcher::codegen::unimplemented_unary(path);
7575 };
7576 let _ = (&ctx, &request, &format);
7577 match method {
7578 "Query" => {
7579 let svc = ::std::sync::Arc::clone(&self.inner);
7580 Box::pin(async move {
7581 let req = ::connectrpc::dispatcher::codegen::decode_request_view::<
7582 __buffa::view::QueryRequestView,
7583 >(request.encoded()?, format)?;
7584 svc.query(ctx, req).await?.encode::<QueryResponse>(format)
7585 })
7586 }
7587 "Tables" => {
7588 let svc = ::std::sync::Arc::clone(&self.inner);
7589 Box::pin(async move {
7590 let req = ::connectrpc::dispatcher::codegen::decode_request_view::<
7591 __buffa::view::TablesRequestView,
7592 >(request.encoded()?, format)?;
7593 svc.tables(ctx, req).await?.encode::<TablesResponse>(format)
7594 })
7595 }
7596 _ => ::connectrpc::dispatcher::codegen::unimplemented_unary(path),
7597 }
7598 }
7599 fn call_server_streaming(
7600 &self,
7601 path: &str,
7602 ctx: ::connectrpc::RequestContext,
7603 request: ::buffa::bytes::Bytes,
7604 format: ::connectrpc::CodecFormat,
7605 ) -> ::connectrpc::dispatcher::codegen::StreamingResult {
7606 let Some(method) = path.strip_prefix("sql.v1.Service/") else {
7607 return ::connectrpc::dispatcher::codegen::unimplemented_streaming(path);
7608 };
7609 let _ = (&ctx, &request, &format);
7610 match method {
7611 "Subscribe" => {
7612 let svc = ::std::sync::Arc::clone(&self.inner);
7613 Box::pin(async move {
7614 let req = ::connectrpc::dispatcher::codegen::decode_request_view::<
7615 __buffa::view::SubscribeRequestView,
7616 >(request, format)?;
7617 let resp = svc.subscribe(ctx, req).await?;
7618 Ok(
7619 resp
7620 .map_body(|s| ::connectrpc::dispatcher::codegen::encode_response_stream::<
7621 SubscribeResponse,
7622 _,
7623 _,
7624 >(s, format)),
7625 )
7626 })
7627 }
7628 _ => ::connectrpc::dispatcher::codegen::unimplemented_streaming(path),
7629 }
7630 }
7631 fn call_client_streaming(
7632 &self,
7633 path: &str,
7634 ctx: ::connectrpc::RequestContext,
7635 requests: ::connectrpc::dispatcher::codegen::RequestStream,
7636 format: ::connectrpc::CodecFormat,
7637 ) -> ::connectrpc::dispatcher::codegen::UnaryResult {
7638 let Some(method) = path.strip_prefix("sql.v1.Service/") else {
7639 return ::connectrpc::dispatcher::codegen::unimplemented_unary(path);
7640 };
7641 let _ = (&ctx, &requests, &format);
7642 match method {
7643 _ => ::connectrpc::dispatcher::codegen::unimplemented_unary(path),
7644 }
7645 }
7646 fn call_bidi_streaming(
7647 &self,
7648 path: &str,
7649 ctx: ::connectrpc::RequestContext,
7650 requests: ::connectrpc::dispatcher::codegen::RequestStream,
7651 format: ::connectrpc::CodecFormat,
7652 ) -> ::connectrpc::dispatcher::codegen::StreamingResult {
7653 let Some(method) = path.strip_prefix("sql.v1.Service/") else {
7654 return ::connectrpc::dispatcher::codegen::unimplemented_streaming(path);
7655 };
7656 let _ = (&ctx, &requests, &format);
7657 match method {
7658 _ => ::connectrpc::dispatcher::codegen::unimplemented_streaming(path),
7659 }
7660 }
7661}
7662#[derive(Clone)]
7712pub struct ServiceClient<T> {
7713 transport: T,
7714 config: ::connectrpc::client::ClientConfig,
7715}
7716impl<T> ServiceClient<T>
7717where
7718 T: ::connectrpc::client::ClientTransport,
7719 <T::ResponseBody as ::http_body::Body>::Error: ::std::fmt::Display,
7720{
7721 pub fn new(transport: T, config: ::connectrpc::client::ClientConfig) -> Self {
7723 Self { transport, config }
7724 }
7725 pub fn config(&self) -> &::connectrpc::client::ClientConfig {
7727 &self.config
7728 }
7729 pub fn config_mut(&mut self) -> &mut ::connectrpc::client::ClientConfig {
7731 &mut self.config
7732 }
7733 pub async fn subscribe(
7735 &self,
7736 request: SubscribeRequest,
7737 ) -> Result<
7738 ::connectrpc::client::ServerStream<
7739 T::ResponseBody,
7740 __buffa::view::SubscribeResponseView<'static>,
7741 >,
7742 ::connectrpc::ConnectError,
7743 > {
7744 self.subscribe_with_options(
7745 request,
7746 ::connectrpc::client::CallOptions::default(),
7747 )
7748 .await
7749 }
7750 pub async fn subscribe_with_options(
7752 &self,
7753 request: SubscribeRequest,
7754 options: ::connectrpc::client::CallOptions,
7755 ) -> Result<
7756 ::connectrpc::client::ServerStream<
7757 T::ResponseBody,
7758 __buffa::view::SubscribeResponseView<'static>,
7759 >,
7760 ::connectrpc::ConnectError,
7761 > {
7762 ::connectrpc::client::call_server_stream(
7763 &self.transport,
7764 &self.config,
7765 SERVICE_SERVICE_NAME,
7766 "Subscribe",
7767 request,
7768 options,
7769 )
7770 .await
7771 }
7772 pub async fn query(
7774 &self,
7775 request: QueryRequest,
7776 ) -> Result<
7777 ::connectrpc::client::UnaryResponse<
7778 ::buffa::view::OwnedView<__buffa::view::QueryResponseView<'static>>,
7779 >,
7780 ::connectrpc::ConnectError,
7781 > {
7782 self.query_with_options(request, ::connectrpc::client::CallOptions::default())
7783 .await
7784 }
7785 pub async fn query_with_options(
7787 &self,
7788 request: QueryRequest,
7789 options: ::connectrpc::client::CallOptions,
7790 ) -> Result<
7791 ::connectrpc::client::UnaryResponse<
7792 ::buffa::view::OwnedView<__buffa::view::QueryResponseView<'static>>,
7793 >,
7794 ::connectrpc::ConnectError,
7795 > {
7796 ::connectrpc::client::call_unary(
7797 &self.transport,
7798 &self.config,
7799 SERVICE_SERVICE_NAME,
7800 "Query",
7801 request,
7802 options,
7803 )
7804 .await
7805 }
7806 pub async fn tables(
7808 &self,
7809 request: TablesRequest,
7810 ) -> Result<
7811 ::connectrpc::client::UnaryResponse<
7812 ::buffa::view::OwnedView<__buffa::view::TablesResponseView<'static>>,
7813 >,
7814 ::connectrpc::ConnectError,
7815 > {
7816 self.tables_with_options(request, ::connectrpc::client::CallOptions::default())
7817 .await
7818 }
7819 pub async fn tables_with_options(
7821 &self,
7822 request: TablesRequest,
7823 options: ::connectrpc::client::CallOptions,
7824 ) -> Result<
7825 ::connectrpc::client::UnaryResponse<
7826 ::buffa::view::OwnedView<__buffa::view::TablesResponseView<'static>>,
7827 >,
7828 ::connectrpc::ConnectError,
7829 > {
7830 ::connectrpc::client::call_unary(
7831 &self.transport,
7832 &self.config,
7833 SERVICE_SERVICE_NAME,
7834 "Tables",
7835 request,
7836 options,
7837 )
7838 .await
7839 }
7840}