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 }
500 }
501 size += self.__buffa_unknown_fields.encoded_len() as u32;
502 size
503 }
504 fn write_to(
505 &self,
506 __cache: &mut ::buffa::SizeCache,
507 buf: &mut impl ::buffa::bytes::BufMut,
508 ) {
509 #[allow(unused_imports)]
510 use ::buffa::Enumeration as _;
511 if let ::core::option::Option::Some(ref v) = self.kind {
512 match v {
513 __buffa::oneof::cell::Kind::NullValue(x) => {
514 ::buffa::encoding::Tag::new(
515 1u32,
516 ::buffa::encoding::WireType::LengthDelimited,
517 )
518 .encode(buf);
519 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
520 x.write_to(__cache, buf);
521 }
522 __buffa::oneof::cell::Kind::Int64Value(x) => {
523 ::buffa::encoding::Tag::new(
524 2u32,
525 ::buffa::encoding::WireType::Varint,
526 )
527 .encode(buf);
528 ::buffa::types::encode_int64(*x, buf);
529 }
530 __buffa::oneof::cell::Kind::Uint64Value(x) => {
531 ::buffa::encoding::Tag::new(
532 3u32,
533 ::buffa::encoding::WireType::Varint,
534 )
535 .encode(buf);
536 ::buffa::types::encode_uint64(*x, buf);
537 }
538 __buffa::oneof::cell::Kind::Float64Value(x) => {
539 ::buffa::encoding::Tag::new(
540 4u32,
541 ::buffa::encoding::WireType::Fixed64,
542 )
543 .encode(buf);
544 ::buffa::types::encode_double(*x, buf);
545 }
546 __buffa::oneof::cell::Kind::BooleanValue(x) => {
547 ::buffa::encoding::Tag::new(
548 5u32,
549 ::buffa::encoding::WireType::Varint,
550 )
551 .encode(buf);
552 ::buffa::types::encode_bool(*x, buf);
553 }
554 __buffa::oneof::cell::Kind::Utf8Value(x) => {
555 ::buffa::encoding::Tag::new(
556 6u32,
557 ::buffa::encoding::WireType::LengthDelimited,
558 )
559 .encode(buf);
560 ::buffa::types::encode_string(x, buf);
561 }
562 __buffa::oneof::cell::Kind::FixedSizeBinaryValue(x) => {
563 ::buffa::encoding::Tag::new(
564 7u32,
565 ::buffa::encoding::WireType::LengthDelimited,
566 )
567 .encode(buf);
568 ::buffa::types::encode_bytes(x, buf);
569 }
570 __buffa::oneof::cell::Kind::Date32Value(x) => {
571 ::buffa::encoding::Tag::new(
572 8u32,
573 ::buffa::encoding::WireType::Varint,
574 )
575 .encode(buf);
576 ::buffa::types::encode_int32(*x, buf);
577 }
578 __buffa::oneof::cell::Kind::Date64Value(x) => {
579 ::buffa::encoding::Tag::new(
580 9u32,
581 ::buffa::encoding::WireType::Varint,
582 )
583 .encode(buf);
584 ::buffa::types::encode_int64(*x, buf);
585 }
586 __buffa::oneof::cell::Kind::TimestampValue(x) => {
587 ::buffa::encoding::Tag::new(
588 10u32,
589 ::buffa::encoding::WireType::Varint,
590 )
591 .encode(buf);
592 ::buffa::types::encode_int64(*x, buf);
593 }
594 __buffa::oneof::cell::Kind::Decimal128Value(x) => {
595 ::buffa::encoding::Tag::new(
596 11u32,
597 ::buffa::encoding::WireType::LengthDelimited,
598 )
599 .encode(buf);
600 ::buffa::types::encode_bytes(x, buf);
601 }
602 __buffa::oneof::cell::Kind::Decimal256Value(x) => {
603 ::buffa::encoding::Tag::new(
604 12u32,
605 ::buffa::encoding::WireType::LengthDelimited,
606 )
607 .encode(buf);
608 ::buffa::types::encode_bytes(x, buf);
609 }
610 __buffa::oneof::cell::Kind::ListValue(x) => {
611 ::buffa::encoding::Tag::new(
612 13u32,
613 ::buffa::encoding::WireType::LengthDelimited,
614 )
615 .encode(buf);
616 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
617 x.write_to(__cache, buf);
618 }
619 }
620 }
621 self.__buffa_unknown_fields.write_to(buf);
622 }
623 fn merge_field(
624 &mut self,
625 tag: ::buffa::encoding::Tag,
626 buf: &mut impl ::buffa::bytes::Buf,
627 depth: u32,
628 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
629 #[allow(unused_imports)]
630 use ::buffa::bytes::Buf as _;
631 #[allow(unused_imports)]
632 use ::buffa::Enumeration as _;
633 match tag.field_number() {
634 1u32 => {
635 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
636 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
637 field_number: 1u32,
638 expected: 2u8,
639 actual: tag.wire_type() as u8,
640 });
641 }
642 if let ::core::option::Option::Some(
643 __buffa::oneof::cell::Kind::NullValue(ref mut existing),
644 ) = self.kind
645 {
646 ::buffa::Message::merge_length_delimited(
647 &mut **existing,
648 buf,
649 depth,
650 )?;
651 } else {
652 let mut val = ::core::default::Default::default();
653 ::buffa::Message::merge_length_delimited(&mut val, buf, depth)?;
654 self.kind = ::core::option::Option::Some(
655 __buffa::oneof::cell::Kind::NullValue(
656 ::buffa::alloc::boxed::Box::new(val),
657 ),
658 );
659 }
660 }
661 2u32 => {
662 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
663 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
664 field_number: 2u32,
665 expected: 0u8,
666 actual: tag.wire_type() as u8,
667 });
668 }
669 self.kind = ::core::option::Option::Some(
670 __buffa::oneof::cell::Kind::Int64Value(
671 ::buffa::types::decode_int64(buf)?,
672 ),
673 );
674 }
675 3u32 => {
676 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
677 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
678 field_number: 3u32,
679 expected: 0u8,
680 actual: tag.wire_type() as u8,
681 });
682 }
683 self.kind = ::core::option::Option::Some(
684 __buffa::oneof::cell::Kind::Uint64Value(
685 ::buffa::types::decode_uint64(buf)?,
686 ),
687 );
688 }
689 4u32 => {
690 if tag.wire_type() != ::buffa::encoding::WireType::Fixed64 {
691 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
692 field_number: 4u32,
693 expected: 1u8,
694 actual: tag.wire_type() as u8,
695 });
696 }
697 self.kind = ::core::option::Option::Some(
698 __buffa::oneof::cell::Kind::Float64Value(
699 ::buffa::types::decode_double(buf)?,
700 ),
701 );
702 }
703 5u32 => {
704 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
705 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
706 field_number: 5u32,
707 expected: 0u8,
708 actual: tag.wire_type() as u8,
709 });
710 }
711 self.kind = ::core::option::Option::Some(
712 __buffa::oneof::cell::Kind::BooleanValue(
713 ::buffa::types::decode_bool(buf)?,
714 ),
715 );
716 }
717 6u32 => {
718 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
719 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
720 field_number: 6u32,
721 expected: 2u8,
722 actual: tag.wire_type() as u8,
723 });
724 }
725 self.kind = ::core::option::Option::Some(
726 __buffa::oneof::cell::Kind::Utf8Value(
727 ::buffa::types::decode_string(buf)?,
728 ),
729 );
730 }
731 7u32 => {
732 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
733 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
734 field_number: 7u32,
735 expected: 2u8,
736 actual: tag.wire_type() as u8,
737 });
738 }
739 self.kind = ::core::option::Option::Some(
740 __buffa::oneof::cell::Kind::FixedSizeBinaryValue(
741 ::buffa::types::decode_bytes_to_bytes(buf)?,
742 ),
743 );
744 }
745 8u32 => {
746 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
747 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
748 field_number: 8u32,
749 expected: 0u8,
750 actual: tag.wire_type() as u8,
751 });
752 }
753 self.kind = ::core::option::Option::Some(
754 __buffa::oneof::cell::Kind::Date32Value(
755 ::buffa::types::decode_int32(buf)?,
756 ),
757 );
758 }
759 9u32 => {
760 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
761 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
762 field_number: 9u32,
763 expected: 0u8,
764 actual: tag.wire_type() as u8,
765 });
766 }
767 self.kind = ::core::option::Option::Some(
768 __buffa::oneof::cell::Kind::Date64Value(
769 ::buffa::types::decode_int64(buf)?,
770 ),
771 );
772 }
773 10u32 => {
774 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
775 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
776 field_number: 10u32,
777 expected: 0u8,
778 actual: tag.wire_type() as u8,
779 });
780 }
781 self.kind = ::core::option::Option::Some(
782 __buffa::oneof::cell::Kind::TimestampValue(
783 ::buffa::types::decode_int64(buf)?,
784 ),
785 );
786 }
787 11u32 => {
788 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
789 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
790 field_number: 11u32,
791 expected: 2u8,
792 actual: tag.wire_type() as u8,
793 });
794 }
795 self.kind = ::core::option::Option::Some(
796 __buffa::oneof::cell::Kind::Decimal128Value(
797 ::buffa::types::decode_bytes_to_bytes(buf)?,
798 ),
799 );
800 }
801 12u32 => {
802 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
803 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
804 field_number: 12u32,
805 expected: 2u8,
806 actual: tag.wire_type() as u8,
807 });
808 }
809 self.kind = ::core::option::Option::Some(
810 __buffa::oneof::cell::Kind::Decimal256Value(
811 ::buffa::types::decode_bytes_to_bytes(buf)?,
812 ),
813 );
814 }
815 13u32 => {
816 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
817 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
818 field_number: 13u32,
819 expected: 2u8,
820 actual: tag.wire_type() as u8,
821 });
822 }
823 if let ::core::option::Option::Some(
824 __buffa::oneof::cell::Kind::ListValue(ref mut existing),
825 ) = self.kind
826 {
827 ::buffa::Message::merge_length_delimited(
828 &mut **existing,
829 buf,
830 depth,
831 )?;
832 } else {
833 let mut val = ::core::default::Default::default();
834 ::buffa::Message::merge_length_delimited(&mut val, buf, depth)?;
835 self.kind = ::core::option::Option::Some(
836 __buffa::oneof::cell::Kind::ListValue(
837 ::buffa::alloc::boxed::Box::new(val),
838 ),
839 );
840 }
841 }
842 _ => {
843 self.__buffa_unknown_fields
844 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
845 }
846 }
847 ::core::result::Result::Ok(())
848 }
849 fn clear(&mut self) {
850 self.kind = ::core::option::Option::None;
851 self.__buffa_unknown_fields.clear();
852 }
853}
854impl ::buffa::ExtensionSet for Cell {
855 const PROTO_FQN: &'static str = "sql.v1.Cell";
856 fn unknown_fields(&self) -> &::buffa::UnknownFields {
857 &self.__buffa_unknown_fields
858 }
859 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
860 &mut self.__buffa_unknown_fields
861 }
862}
863impl<'de> serde::Deserialize<'de> for Cell {
864 fn deserialize<D: serde::Deserializer<'de>>(
865 d: D,
866 ) -> ::core::result::Result<Self, D::Error> {
867 struct _V;
868 impl<'de> serde::de::Visitor<'de> for _V {
869 type Value = Cell;
870 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
871 f.write_str("struct Cell")
872 }
873 #[allow(clippy::field_reassign_with_default)]
874 fn visit_map<A: serde::de::MapAccess<'de>>(
875 self,
876 mut map: A,
877 ) -> ::core::result::Result<Cell, A::Error> {
878 let mut __oneof_kind: ::core::option::Option<
879 __buffa::oneof::cell::Kind,
880 > = None;
881 while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
882 match key.as_str() {
883 "nullValue" | "null_value" => {
884 let v: ::core::option::Option<Null> = map
885 .next_value_seed(
886 ::buffa::json_helpers::NullableDeserializeSeed(
887 ::buffa::json_helpers::DefaultDeserializeSeed::<Null>::new(),
888 ),
889 )?;
890 if let Some(v) = v {
891 if __oneof_kind.is_some() {
892 return Err(
893 serde::de::Error::custom(
894 "multiple oneof fields set for 'kind'",
895 ),
896 );
897 }
898 __oneof_kind = Some(
899 __buffa::oneof::cell::Kind::NullValue(
900 ::buffa::alloc::boxed::Box::new(v),
901 ),
902 );
903 }
904 }
905 "int64Value" | "int64_value" => {
906 struct _DeserSeed;
907 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
908 type Value = i64;
909 fn deserialize<D: serde::Deserializer<'de>>(
910 self,
911 d: D,
912 ) -> ::core::result::Result<i64, D::Error> {
913 ::buffa::json_helpers::int64::deserialize(d)
914 }
915 }
916 let v: ::core::option::Option<i64> = map
917 .next_value_seed(
918 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
919 )?;
920 if let Some(v) = v {
921 if __oneof_kind.is_some() {
922 return Err(
923 serde::de::Error::custom(
924 "multiple oneof fields set for 'kind'",
925 ),
926 );
927 }
928 __oneof_kind = Some(
929 __buffa::oneof::cell::Kind::Int64Value(v),
930 );
931 }
932 }
933 "uint64Value" | "uint64_value" => {
934 struct _DeserSeed;
935 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
936 type Value = u64;
937 fn deserialize<D: serde::Deserializer<'de>>(
938 self,
939 d: D,
940 ) -> ::core::result::Result<u64, D::Error> {
941 ::buffa::json_helpers::uint64::deserialize(d)
942 }
943 }
944 let v: ::core::option::Option<u64> = map
945 .next_value_seed(
946 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
947 )?;
948 if let Some(v) = v {
949 if __oneof_kind.is_some() {
950 return Err(
951 serde::de::Error::custom(
952 "multiple oneof fields set for 'kind'",
953 ),
954 );
955 }
956 __oneof_kind = Some(
957 __buffa::oneof::cell::Kind::Uint64Value(v),
958 );
959 }
960 }
961 "float64Value" | "float64_value" => {
962 struct _DeserSeed;
963 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
964 type Value = f64;
965 fn deserialize<D: serde::Deserializer<'de>>(
966 self,
967 d: D,
968 ) -> ::core::result::Result<f64, D::Error> {
969 ::buffa::json_helpers::double::deserialize(d)
970 }
971 }
972 let v: ::core::option::Option<f64> = map
973 .next_value_seed(
974 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
975 )?;
976 if let Some(v) = v {
977 if __oneof_kind.is_some() {
978 return Err(
979 serde::de::Error::custom(
980 "multiple oneof fields set for 'kind'",
981 ),
982 );
983 }
984 __oneof_kind = Some(
985 __buffa::oneof::cell::Kind::Float64Value(v),
986 );
987 }
988 }
989 "booleanValue" | "boolean_value" => {
990 let v: ::core::option::Option<bool> = map
991 .next_value_seed(
992 ::buffa::json_helpers::NullableDeserializeSeed(
993 ::buffa::json_helpers::DefaultDeserializeSeed::<bool>::new(),
994 ),
995 )?;
996 if let Some(v) = v {
997 if __oneof_kind.is_some() {
998 return Err(
999 serde::de::Error::custom(
1000 "multiple oneof fields set for 'kind'",
1001 ),
1002 );
1003 }
1004 __oneof_kind = Some(
1005 __buffa::oneof::cell::Kind::BooleanValue(v),
1006 );
1007 }
1008 }
1009 "utf8Value" | "utf8_value" => {
1010 let v: ::core::option::Option<
1011 ::buffa::alloc::string::String,
1012 > = map
1013 .next_value_seed(
1014 ::buffa::json_helpers::NullableDeserializeSeed(
1015 ::buffa::json_helpers::DefaultDeserializeSeed::<
1016 ::buffa::alloc::string::String,
1017 >::new(),
1018 ),
1019 )?;
1020 if let Some(v) = v {
1021 if __oneof_kind.is_some() {
1022 return Err(
1023 serde::de::Error::custom(
1024 "multiple oneof fields set for 'kind'",
1025 ),
1026 );
1027 }
1028 __oneof_kind = Some(
1029 __buffa::oneof::cell::Kind::Utf8Value(v),
1030 );
1031 }
1032 }
1033 "fixedSizeBinaryValue" | "fixed_size_binary_value" => {
1034 struct _DeserSeed;
1035 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1036 type Value = ::buffa::bytes::Bytes;
1037 fn deserialize<D: serde::Deserializer<'de>>(
1038 self,
1039 d: D,
1040 ) -> ::core::result::Result<
1041 ::buffa::bytes::Bytes,
1042 D::Error,
1043 > {
1044 ::buffa::json_helpers::bytes::deserialize(d)
1045 }
1046 }
1047 let v: ::core::option::Option<::buffa::bytes::Bytes> = map
1048 .next_value_seed(
1049 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1050 )?;
1051 if let Some(v) = v {
1052 if __oneof_kind.is_some() {
1053 return Err(
1054 serde::de::Error::custom(
1055 "multiple oneof fields set for 'kind'",
1056 ),
1057 );
1058 }
1059 __oneof_kind = Some(
1060 __buffa::oneof::cell::Kind::FixedSizeBinaryValue(v),
1061 );
1062 }
1063 }
1064 "date32Value" | "date32_value" => {
1065 struct _DeserSeed;
1066 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1067 type Value = i32;
1068 fn deserialize<D: serde::Deserializer<'de>>(
1069 self,
1070 d: D,
1071 ) -> ::core::result::Result<i32, D::Error> {
1072 ::buffa::json_helpers::int32::deserialize(d)
1073 }
1074 }
1075 let v: ::core::option::Option<i32> = map
1076 .next_value_seed(
1077 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1078 )?;
1079 if let Some(v) = v {
1080 if __oneof_kind.is_some() {
1081 return Err(
1082 serde::de::Error::custom(
1083 "multiple oneof fields set for 'kind'",
1084 ),
1085 );
1086 }
1087 __oneof_kind = Some(
1088 __buffa::oneof::cell::Kind::Date32Value(v),
1089 );
1090 }
1091 }
1092 "date64Value" | "date64_value" => {
1093 struct _DeserSeed;
1094 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1095 type Value = i64;
1096 fn deserialize<D: serde::Deserializer<'de>>(
1097 self,
1098 d: D,
1099 ) -> ::core::result::Result<i64, D::Error> {
1100 ::buffa::json_helpers::int64::deserialize(d)
1101 }
1102 }
1103 let v: ::core::option::Option<i64> = map
1104 .next_value_seed(
1105 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1106 )?;
1107 if let Some(v) = v {
1108 if __oneof_kind.is_some() {
1109 return Err(
1110 serde::de::Error::custom(
1111 "multiple oneof fields set for 'kind'",
1112 ),
1113 );
1114 }
1115 __oneof_kind = Some(
1116 __buffa::oneof::cell::Kind::Date64Value(v),
1117 );
1118 }
1119 }
1120 "timestampValue" | "timestamp_value" => {
1121 struct _DeserSeed;
1122 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1123 type Value = i64;
1124 fn deserialize<D: serde::Deserializer<'de>>(
1125 self,
1126 d: D,
1127 ) -> ::core::result::Result<i64, D::Error> {
1128 ::buffa::json_helpers::int64::deserialize(d)
1129 }
1130 }
1131 let v: ::core::option::Option<i64> = map
1132 .next_value_seed(
1133 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1134 )?;
1135 if let Some(v) = v {
1136 if __oneof_kind.is_some() {
1137 return Err(
1138 serde::de::Error::custom(
1139 "multiple oneof fields set for 'kind'",
1140 ),
1141 );
1142 }
1143 __oneof_kind = Some(
1144 __buffa::oneof::cell::Kind::TimestampValue(v),
1145 );
1146 }
1147 }
1148 "decimal128Value" | "decimal128_value" => {
1149 struct _DeserSeed;
1150 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1151 type Value = ::buffa::bytes::Bytes;
1152 fn deserialize<D: serde::Deserializer<'de>>(
1153 self,
1154 d: D,
1155 ) -> ::core::result::Result<
1156 ::buffa::bytes::Bytes,
1157 D::Error,
1158 > {
1159 ::buffa::json_helpers::bytes::deserialize(d)
1160 }
1161 }
1162 let v: ::core::option::Option<::buffa::bytes::Bytes> = map
1163 .next_value_seed(
1164 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1165 )?;
1166 if let Some(v) = v {
1167 if __oneof_kind.is_some() {
1168 return Err(
1169 serde::de::Error::custom(
1170 "multiple oneof fields set for 'kind'",
1171 ),
1172 );
1173 }
1174 __oneof_kind = Some(
1175 __buffa::oneof::cell::Kind::Decimal128Value(v),
1176 );
1177 }
1178 }
1179 "decimal256Value" | "decimal256_value" => {
1180 struct _DeserSeed;
1181 impl<'de> serde::de::DeserializeSeed<'de> for _DeserSeed {
1182 type Value = ::buffa::bytes::Bytes;
1183 fn deserialize<D: serde::Deserializer<'de>>(
1184 self,
1185 d: D,
1186 ) -> ::core::result::Result<
1187 ::buffa::bytes::Bytes,
1188 D::Error,
1189 > {
1190 ::buffa::json_helpers::bytes::deserialize(d)
1191 }
1192 }
1193 let v: ::core::option::Option<::buffa::bytes::Bytes> = map
1194 .next_value_seed(
1195 ::buffa::json_helpers::NullableDeserializeSeed(_DeserSeed),
1196 )?;
1197 if let Some(v) = v {
1198 if __oneof_kind.is_some() {
1199 return Err(
1200 serde::de::Error::custom(
1201 "multiple oneof fields set for 'kind'",
1202 ),
1203 );
1204 }
1205 __oneof_kind = Some(
1206 __buffa::oneof::cell::Kind::Decimal256Value(v),
1207 );
1208 }
1209 }
1210 "listValue" | "list_value" => {
1211 let v: ::core::option::Option<ListValue> = map
1212 .next_value_seed(
1213 ::buffa::json_helpers::NullableDeserializeSeed(
1214 ::buffa::json_helpers::DefaultDeserializeSeed::<
1215 ListValue,
1216 >::new(),
1217 ),
1218 )?;
1219 if let Some(v) = v {
1220 if __oneof_kind.is_some() {
1221 return Err(
1222 serde::de::Error::custom(
1223 "multiple oneof fields set for 'kind'",
1224 ),
1225 );
1226 }
1227 __oneof_kind = Some(
1228 __buffa::oneof::cell::Kind::ListValue(
1229 ::buffa::alloc::boxed::Box::new(v),
1230 ),
1231 );
1232 }
1233 }
1234 _ => {
1235 map.next_value::<serde::de::IgnoredAny>()?;
1236 }
1237 }
1238 }
1239 let mut __r = <Cell as ::core::default::Default>::default();
1240 __r.kind = __oneof_kind;
1241 Ok(__r)
1242 }
1243 }
1244 d.deserialize_map(_V)
1245 }
1246}
1247impl ::buffa::json_helpers::ProtoElemJson for Cell {
1248 fn serialize_proto_json<S: ::serde::Serializer>(
1249 v: &Self,
1250 s: S,
1251 ) -> ::core::result::Result<S::Ok, S::Error> {
1252 ::serde::Serialize::serialize(v, s)
1253 }
1254 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1255 d: D,
1256 ) -> ::core::result::Result<Self, D::Error> {
1257 <Self as ::serde::Deserialize>::deserialize(d)
1258 }
1259}
1260#[doc(hidden)]
1261pub const __CELL_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1262 type_url: "type.googleapis.com/sql.v1.Cell",
1263 to_json: ::buffa::type_registry::any_to_json::<Cell>,
1264 from_json: ::buffa::type_registry::any_from_json::<Cell>,
1265 is_wkt: false,
1266};
1267pub mod cell {
1268 #[allow(unused_imports)]
1269 use super::*;
1270 #[doc(inline)]
1271 pub use super::__buffa::oneof::cell::Kind;
1272 #[doc(inline)]
1273 pub use super::__buffa::view::oneof::cell::Kind as KindView;
1274}
1275#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
1277#[repr(i32)]
1278pub enum IndexLayout {
1279 INDEX_LAYOUT_LEXICOGRAPHIC = 0i32,
1281 INDEX_LAYOUT_Z_ORDER = 1i32,
1284}
1285impl ::core::default::Default for IndexLayout {
1286 fn default() -> Self {
1287 Self::INDEX_LAYOUT_LEXICOGRAPHIC
1288 }
1289}
1290impl ::serde::Serialize for IndexLayout {
1291 fn serialize<S: ::serde::Serializer>(
1292 &self,
1293 s: S,
1294 ) -> ::core::result::Result<S::Ok, S::Error> {
1295 s.serialize_str(::buffa::Enumeration::proto_name(self))
1296 }
1297}
1298impl<'de> ::serde::Deserialize<'de> for IndexLayout {
1299 fn deserialize<D: ::serde::Deserializer<'de>>(
1300 d: D,
1301 ) -> ::core::result::Result<Self, D::Error> {
1302 struct _V;
1303 impl ::serde::de::Visitor<'_> for _V {
1304 type Value = IndexLayout;
1305 fn expecting(
1306 &self,
1307 f: &mut ::core::fmt::Formatter<'_>,
1308 ) -> ::core::fmt::Result {
1309 f.write_str(
1310 concat!("a string, integer, or null for ", stringify!(IndexLayout)),
1311 )
1312 }
1313 fn visit_str<E: ::serde::de::Error>(
1314 self,
1315 v: &str,
1316 ) -> ::core::result::Result<IndexLayout, E> {
1317 <IndexLayout as ::buffa::Enumeration>::from_proto_name(v)
1318 .ok_or_else(|| { ::serde::de::Error::unknown_variant(v, &[]) })
1319 }
1320 fn visit_i64<E: ::serde::de::Error>(
1321 self,
1322 v: i64,
1323 ) -> ::core::result::Result<IndexLayout, E> {
1324 let v32 = i32::try_from(v)
1325 .map_err(|_| {
1326 ::serde::de::Error::custom(
1327 ::buffa::alloc::format!("enum value {v} out of i32 range"),
1328 )
1329 })?;
1330 <IndexLayout as ::buffa::Enumeration>::from_i32(v32)
1331 .ok_or_else(|| {
1332 ::serde::de::Error::custom(
1333 ::buffa::alloc::format!("unknown enum value {v32}"),
1334 )
1335 })
1336 }
1337 fn visit_u64<E: ::serde::de::Error>(
1338 self,
1339 v: u64,
1340 ) -> ::core::result::Result<IndexLayout, E> {
1341 let v32 = i32::try_from(v)
1342 .map_err(|_| {
1343 ::serde::de::Error::custom(
1344 ::buffa::alloc::format!("enum value {v} out of i32 range"),
1345 )
1346 })?;
1347 <IndexLayout as ::buffa::Enumeration>::from_i32(v32)
1348 .ok_or_else(|| {
1349 ::serde::de::Error::custom(
1350 ::buffa::alloc::format!("unknown enum value {v32}"),
1351 )
1352 })
1353 }
1354 fn visit_unit<E: ::serde::de::Error>(
1355 self,
1356 ) -> ::core::result::Result<IndexLayout, E> {
1357 ::core::result::Result::Ok(::core::default::Default::default())
1358 }
1359 }
1360 d.deserialize_any(_V)
1361 }
1362}
1363impl ::buffa::json_helpers::ProtoElemJson for IndexLayout {
1364 fn serialize_proto_json<S: ::serde::Serializer>(
1365 v: &Self,
1366 s: S,
1367 ) -> ::core::result::Result<S::Ok, S::Error> {
1368 ::serde::Serialize::serialize(v, s)
1369 }
1370 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1371 d: D,
1372 ) -> ::core::result::Result<Self, D::Error> {
1373 <Self as ::serde::Deserialize>::deserialize(d)
1374 }
1375}
1376impl ::buffa::Enumeration for IndexLayout {
1377 fn from_i32(value: i32) -> ::core::option::Option<Self> {
1378 match value {
1379 0i32 => ::core::option::Option::Some(Self::INDEX_LAYOUT_LEXICOGRAPHIC),
1380 1i32 => ::core::option::Option::Some(Self::INDEX_LAYOUT_Z_ORDER),
1381 _ => ::core::option::Option::None,
1382 }
1383 }
1384 fn to_i32(&self) -> i32 {
1385 *self as i32
1386 }
1387 fn proto_name(&self) -> &'static str {
1388 match self {
1389 Self::INDEX_LAYOUT_LEXICOGRAPHIC => "INDEX_LAYOUT_LEXICOGRAPHIC",
1390 Self::INDEX_LAYOUT_Z_ORDER => "INDEX_LAYOUT_Z_ORDER",
1391 }
1392 }
1393 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
1394 match name {
1395 "INDEX_LAYOUT_LEXICOGRAPHIC" => {
1396 ::core::option::Option::Some(Self::INDEX_LAYOUT_LEXICOGRAPHIC)
1397 }
1398 "INDEX_LAYOUT_Z_ORDER" => {
1399 ::core::option::Option::Some(Self::INDEX_LAYOUT_Z_ORDER)
1400 }
1401 _ => ::core::option::Option::None,
1402 }
1403 }
1404 fn values() -> &'static [Self] {
1405 &[Self::INDEX_LAYOUT_LEXICOGRAPHIC, Self::INDEX_LAYOUT_Z_ORDER]
1406 }
1407}
1408#[derive(Clone, PartialEq, Default)]
1410#[derive(::serde::Serialize, ::serde::Deserialize)]
1411#[serde(default)]
1412pub struct TablesResponse {
1413 #[serde(
1415 rename = "tables",
1416 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1417 deserialize_with = "::buffa::json_helpers::null_as_default"
1418 )]
1419 pub tables: ::buffa::alloc::vec::Vec<Table>,
1420 #[serde(skip)]
1421 #[doc(hidden)]
1422 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1423}
1424impl ::core::fmt::Debug for TablesResponse {
1425 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1426 f.debug_struct("TablesResponse").field("tables", &self.tables).finish()
1427 }
1428}
1429impl TablesResponse {
1430 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesResponse";
1435}
1436impl ::buffa::DefaultInstance for TablesResponse {
1437 fn default_instance() -> &'static Self {
1438 static VALUE: ::buffa::__private::OnceBox<TablesResponse> = ::buffa::__private::OnceBox::new();
1439 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
1440 }
1441}
1442impl ::buffa::MessageName for TablesResponse {
1443 const PACKAGE: &'static str = "sql.v1";
1444 const NAME: &'static str = "TablesResponse";
1445 const FULL_NAME: &'static str = "sql.v1.TablesResponse";
1446 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesResponse";
1447}
1448impl ::buffa::Message for TablesResponse {
1449 #[allow(clippy::let_and_return)]
1455 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1456 #[allow(unused_imports)]
1457 use ::buffa::Enumeration as _;
1458 let mut size = 0u32;
1459 for v in &self.tables {
1460 let __slot = __cache.reserve();
1461 let inner_size = v.compute_size(__cache);
1462 __cache.set(__slot, inner_size);
1463 size
1464 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1465 + inner_size;
1466 }
1467 size += self.__buffa_unknown_fields.encoded_len() as u32;
1468 size
1469 }
1470 fn write_to(
1471 &self,
1472 __cache: &mut ::buffa::SizeCache,
1473 buf: &mut impl ::buffa::bytes::BufMut,
1474 ) {
1475 #[allow(unused_imports)]
1476 use ::buffa::Enumeration as _;
1477 for v in &self.tables {
1478 ::buffa::encoding::Tag::new(
1479 1u32,
1480 ::buffa::encoding::WireType::LengthDelimited,
1481 )
1482 .encode(buf);
1483 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
1484 v.write_to(__cache, buf);
1485 }
1486 self.__buffa_unknown_fields.write_to(buf);
1487 }
1488 fn merge_field(
1489 &mut self,
1490 tag: ::buffa::encoding::Tag,
1491 buf: &mut impl ::buffa::bytes::Buf,
1492 depth: u32,
1493 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1494 #[allow(unused_imports)]
1495 use ::buffa::bytes::Buf as _;
1496 #[allow(unused_imports)]
1497 use ::buffa::Enumeration as _;
1498 match tag.field_number() {
1499 1u32 => {
1500 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1501 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1502 field_number: 1u32,
1503 expected: 2u8,
1504 actual: tag.wire_type() as u8,
1505 });
1506 }
1507 let mut elem = ::core::default::Default::default();
1508 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1509 self.tables.push(elem);
1510 }
1511 _ => {
1512 self.__buffa_unknown_fields
1513 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1514 }
1515 }
1516 ::core::result::Result::Ok(())
1517 }
1518 fn clear(&mut self) {
1519 self.tables.clear();
1520 self.__buffa_unknown_fields.clear();
1521 }
1522}
1523impl ::buffa::ExtensionSet for TablesResponse {
1524 const PROTO_FQN: &'static str = "sql.v1.TablesResponse";
1525 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1526 &self.__buffa_unknown_fields
1527 }
1528 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1529 &mut self.__buffa_unknown_fields
1530 }
1531}
1532impl ::buffa::json_helpers::ProtoElemJson for TablesResponse {
1533 fn serialize_proto_json<S: ::serde::Serializer>(
1534 v: &Self,
1535 s: S,
1536 ) -> ::core::result::Result<S::Ok, S::Error> {
1537 ::serde::Serialize::serialize(v, s)
1538 }
1539 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1540 d: D,
1541 ) -> ::core::result::Result<Self, D::Error> {
1542 <Self as ::serde::Deserialize>::deserialize(d)
1543 }
1544}
1545#[doc(hidden)]
1546pub const __TABLES_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1547 type_url: "type.googleapis.com/sql.v1.TablesResponse",
1548 to_json: ::buffa::type_registry::any_to_json::<TablesResponse>,
1549 from_json: ::buffa::type_registry::any_from_json::<TablesResponse>,
1550 is_wkt: false,
1551};
1552#[derive(Clone, PartialEq, Default)]
1554#[derive(::serde::Serialize, ::serde::Deserialize)]
1555#[serde(default)]
1556pub struct TablesRequest {
1557 #[serde(skip)]
1558 #[doc(hidden)]
1559 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1560}
1561impl ::core::fmt::Debug for TablesRequest {
1562 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1563 f.debug_struct("TablesRequest").finish()
1564 }
1565}
1566impl TablesRequest {
1567 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesRequest";
1572}
1573impl ::buffa::DefaultInstance for TablesRequest {
1574 fn default_instance() -> &'static Self {
1575 static VALUE: ::buffa::__private::OnceBox<TablesRequest> = ::buffa::__private::OnceBox::new();
1576 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
1577 }
1578}
1579impl ::buffa::MessageName for TablesRequest {
1580 const PACKAGE: &'static str = "sql.v1";
1581 const NAME: &'static str = "TablesRequest";
1582 const FULL_NAME: &'static str = "sql.v1.TablesRequest";
1583 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesRequest";
1584}
1585impl ::buffa::Message for TablesRequest {
1586 #[allow(clippy::let_and_return)]
1592 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
1593 #[allow(unused_imports)]
1594 use ::buffa::Enumeration as _;
1595 let mut size = 0u32;
1596 size += self.__buffa_unknown_fields.encoded_len() as u32;
1597 size
1598 }
1599 fn write_to(
1600 &self,
1601 _cache: &mut ::buffa::SizeCache,
1602 buf: &mut impl ::buffa::bytes::BufMut,
1603 ) {
1604 #[allow(unused_imports)]
1605 use ::buffa::Enumeration as _;
1606 self.__buffa_unknown_fields.write_to(buf);
1607 }
1608 fn merge_field(
1609 &mut self,
1610 tag: ::buffa::encoding::Tag,
1611 buf: &mut impl ::buffa::bytes::Buf,
1612 depth: u32,
1613 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1614 #[allow(unused_imports)]
1615 use ::buffa::bytes::Buf as _;
1616 #[allow(unused_imports)]
1617 use ::buffa::Enumeration as _;
1618 match tag.field_number() {
1619 _ => {
1620 self.__buffa_unknown_fields
1621 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1622 }
1623 }
1624 ::core::result::Result::Ok(())
1625 }
1626 fn clear(&mut self) {
1627 self.__buffa_unknown_fields.clear();
1628 }
1629}
1630impl ::buffa::ExtensionSet for TablesRequest {
1631 const PROTO_FQN: &'static str = "sql.v1.TablesRequest";
1632 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1633 &self.__buffa_unknown_fields
1634 }
1635 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1636 &mut self.__buffa_unknown_fields
1637 }
1638}
1639impl ::buffa::json_helpers::ProtoElemJson for TablesRequest {
1640 fn serialize_proto_json<S: ::serde::Serializer>(
1641 v: &Self,
1642 s: S,
1643 ) -> ::core::result::Result<S::Ok, S::Error> {
1644 ::serde::Serialize::serialize(v, s)
1645 }
1646 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1647 d: D,
1648 ) -> ::core::result::Result<Self, D::Error> {
1649 <Self as ::serde::Deserialize>::deserialize(d)
1650 }
1651}
1652#[doc(hidden)]
1653pub const __TABLES_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1654 type_url: "type.googleapis.com/sql.v1.TablesRequest",
1655 to_json: ::buffa::type_registry::any_to_json::<TablesRequest>,
1656 from_json: ::buffa::type_registry::any_from_json::<TablesRequest>,
1657 is_wkt: false,
1658};
1659#[derive(Clone, PartialEq, Default)]
1661#[derive(::serde::Serialize, ::serde::Deserialize)]
1662#[serde(default)]
1663pub struct Table {
1664 #[serde(
1668 rename = "name",
1669 with = "::buffa::json_helpers::proto_string",
1670 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
1671 )]
1672 pub name: ::buffa::alloc::string::String,
1673 #[serde(
1677 rename = "columns",
1678 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1679 deserialize_with = "::buffa::json_helpers::null_as_default"
1680 )]
1681 pub columns: ::buffa::alloc::vec::Vec<Column>,
1682 #[serde(
1686 rename = "primaryKeyColumns",
1687 alias = "primary_key_columns",
1688 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1689 deserialize_with = "::buffa::json_helpers::null_as_default"
1690 )]
1691 pub primary_key_columns: ::buffa::alloc::vec::Vec<u32>,
1692 #[serde(
1696 rename = "indexes",
1697 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1698 deserialize_with = "::buffa::json_helpers::null_as_default"
1699 )]
1700 pub indexes: ::buffa::alloc::vec::Vec<Index>,
1701 #[serde(skip)]
1702 #[doc(hidden)]
1703 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1704}
1705impl ::core::fmt::Debug for Table {
1706 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1707 f.debug_struct("Table")
1708 .field("name", &self.name)
1709 .field("columns", &self.columns)
1710 .field("primary_key_columns", &self.primary_key_columns)
1711 .field("indexes", &self.indexes)
1712 .finish()
1713 }
1714}
1715impl Table {
1716 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Table";
1721}
1722impl ::buffa::DefaultInstance for Table {
1723 fn default_instance() -> &'static Self {
1724 static VALUE: ::buffa::__private::OnceBox<Table> = ::buffa::__private::OnceBox::new();
1725 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
1726 }
1727}
1728impl ::buffa::MessageName for Table {
1729 const PACKAGE: &'static str = "sql.v1";
1730 const NAME: &'static str = "Table";
1731 const FULL_NAME: &'static str = "sql.v1.Table";
1732 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Table";
1733}
1734impl ::buffa::Message for Table {
1735 #[allow(clippy::let_and_return)]
1741 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1742 #[allow(unused_imports)]
1743 use ::buffa::Enumeration as _;
1744 let mut size = 0u32;
1745 if !self.name.is_empty() {
1746 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
1747 }
1748 for v in &self.columns {
1749 let __slot = __cache.reserve();
1750 let inner_size = v.compute_size(__cache);
1751 __cache.set(__slot, inner_size);
1752 size
1753 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1754 + inner_size;
1755 }
1756 if !self.primary_key_columns.is_empty() {
1757 let payload: u32 = self
1758 .primary_key_columns
1759 .iter()
1760 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
1761 .sum::<u32>();
1762 size
1763 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
1764 }
1765 for v in &self.indexes {
1766 let __slot = __cache.reserve();
1767 let inner_size = v.compute_size(__cache);
1768 __cache.set(__slot, inner_size);
1769 size
1770 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1771 + inner_size;
1772 }
1773 size += self.__buffa_unknown_fields.encoded_len() as u32;
1774 size
1775 }
1776 fn write_to(
1777 &self,
1778 __cache: &mut ::buffa::SizeCache,
1779 buf: &mut impl ::buffa::bytes::BufMut,
1780 ) {
1781 #[allow(unused_imports)]
1782 use ::buffa::Enumeration as _;
1783 if !self.name.is_empty() {
1784 ::buffa::encoding::Tag::new(
1785 1u32,
1786 ::buffa::encoding::WireType::LengthDelimited,
1787 )
1788 .encode(buf);
1789 ::buffa::types::encode_string(&self.name, buf);
1790 }
1791 for v in &self.columns {
1792 ::buffa::encoding::Tag::new(
1793 2u32,
1794 ::buffa::encoding::WireType::LengthDelimited,
1795 )
1796 .encode(buf);
1797 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
1798 v.write_to(__cache, buf);
1799 }
1800 if !self.primary_key_columns.is_empty() {
1801 let payload: u32 = self
1802 .primary_key_columns
1803 .iter()
1804 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
1805 .sum::<u32>();
1806 ::buffa::encoding::Tag::new(
1807 3u32,
1808 ::buffa::encoding::WireType::LengthDelimited,
1809 )
1810 .encode(buf);
1811 ::buffa::encoding::encode_varint(payload as u64, buf);
1812 for &v in &self.primary_key_columns {
1813 ::buffa::types::encode_uint32(v, buf);
1814 }
1815 }
1816 for v in &self.indexes {
1817 ::buffa::encoding::Tag::new(
1818 4u32,
1819 ::buffa::encoding::WireType::LengthDelimited,
1820 )
1821 .encode(buf);
1822 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
1823 v.write_to(__cache, buf);
1824 }
1825 self.__buffa_unknown_fields.write_to(buf);
1826 }
1827 fn merge_field(
1828 &mut self,
1829 tag: ::buffa::encoding::Tag,
1830 buf: &mut impl ::buffa::bytes::Buf,
1831 depth: u32,
1832 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1833 #[allow(unused_imports)]
1834 use ::buffa::bytes::Buf as _;
1835 #[allow(unused_imports)]
1836 use ::buffa::Enumeration as _;
1837 match tag.field_number() {
1838 1u32 => {
1839 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1840 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1841 field_number: 1u32,
1842 expected: 2u8,
1843 actual: tag.wire_type() as u8,
1844 });
1845 }
1846 ::buffa::types::merge_string(&mut self.name, buf)?;
1847 }
1848 2u32 => {
1849 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1850 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1851 field_number: 2u32,
1852 expected: 2u8,
1853 actual: tag.wire_type() as u8,
1854 });
1855 }
1856 let mut elem = ::core::default::Default::default();
1857 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1858 self.columns.push(elem);
1859 }
1860 3u32 => {
1861 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
1862 let len = ::buffa::encoding::decode_varint(buf)?;
1863 let len = usize::try_from(len)
1864 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
1865 if buf.remaining() < len {
1866 return ::core::result::Result::Err(
1867 ::buffa::DecodeError::UnexpectedEof,
1868 );
1869 }
1870 self.primary_key_columns.reserve(len);
1871 let mut limited = buf.take(len);
1872 while limited.has_remaining() {
1873 self.primary_key_columns
1874 .push(::buffa::types::decode_uint32(&mut limited)?);
1875 }
1876 let leftover = limited.remaining();
1877 if leftover > 0 {
1878 limited.advance(leftover);
1879 }
1880 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
1881 self.primary_key_columns.push(::buffa::types::decode_uint32(buf)?);
1882 } else {
1883 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1884 field_number: 3u32,
1885 expected: 2u8,
1886 actual: tag.wire_type() as u8,
1887 });
1888 }
1889 }
1890 4u32 => {
1891 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1892 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1893 field_number: 4u32,
1894 expected: 2u8,
1895 actual: tag.wire_type() as u8,
1896 });
1897 }
1898 let mut elem = ::core::default::Default::default();
1899 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1900 self.indexes.push(elem);
1901 }
1902 _ => {
1903 self.__buffa_unknown_fields
1904 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1905 }
1906 }
1907 ::core::result::Result::Ok(())
1908 }
1909 fn clear(&mut self) {
1910 self.name.clear();
1911 self.columns.clear();
1912 self.primary_key_columns.clear();
1913 self.indexes.clear();
1914 self.__buffa_unknown_fields.clear();
1915 }
1916}
1917impl ::buffa::ExtensionSet for Table {
1918 const PROTO_FQN: &'static str = "sql.v1.Table";
1919 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1920 &self.__buffa_unknown_fields
1921 }
1922 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1923 &mut self.__buffa_unknown_fields
1924 }
1925}
1926impl ::buffa::json_helpers::ProtoElemJson for Table {
1927 fn serialize_proto_json<S: ::serde::Serializer>(
1928 v: &Self,
1929 s: S,
1930 ) -> ::core::result::Result<S::Ok, S::Error> {
1931 ::serde::Serialize::serialize(v, s)
1932 }
1933 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1934 d: D,
1935 ) -> ::core::result::Result<Self, D::Error> {
1936 <Self as ::serde::Deserialize>::deserialize(d)
1937 }
1938}
1939#[doc(hidden)]
1940pub const __TABLE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1941 type_url: "type.googleapis.com/sql.v1.Table",
1942 to_json: ::buffa::type_registry::any_to_json::<Table>,
1943 from_json: ::buffa::type_registry::any_from_json::<Table>,
1944 is_wkt: false,
1945};
1946#[derive(Clone, PartialEq, Default)]
1948#[derive(::serde::Serialize, ::serde::Deserialize)]
1949#[serde(default)]
1950pub struct Column {
1951 #[serde(
1953 rename = "name",
1954 with = "::buffa::json_helpers::proto_string",
1955 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
1956 )]
1957 pub name: ::buffa::alloc::string::String,
1958 #[serde(
1964 rename = "dataType",
1965 alias = "data_type",
1966 with = "::buffa::json_helpers::proto_string",
1967 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
1968 )]
1969 pub data_type: ::buffa::alloc::string::String,
1970 #[serde(
1972 rename = "nullable",
1973 with = "::buffa::json_helpers::proto_bool",
1974 skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
1975 )]
1976 pub nullable: bool,
1977 #[serde(skip)]
1978 #[doc(hidden)]
1979 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1980}
1981impl ::core::fmt::Debug for Column {
1982 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1983 f.debug_struct("Column")
1984 .field("name", &self.name)
1985 .field("data_type", &self.data_type)
1986 .field("nullable", &self.nullable)
1987 .finish()
1988 }
1989}
1990impl Column {
1991 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Column";
1996}
1997impl ::buffa::DefaultInstance for Column {
1998 fn default_instance() -> &'static Self {
1999 static VALUE: ::buffa::__private::OnceBox<Column> = ::buffa::__private::OnceBox::new();
2000 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2001 }
2002}
2003impl ::buffa::MessageName for Column {
2004 const PACKAGE: &'static str = "sql.v1";
2005 const NAME: &'static str = "Column";
2006 const FULL_NAME: &'static str = "sql.v1.Column";
2007 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Column";
2008}
2009impl ::buffa::Message for Column {
2010 #[allow(clippy::let_and_return)]
2016 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
2017 #[allow(unused_imports)]
2018 use ::buffa::Enumeration as _;
2019 let mut size = 0u32;
2020 if !self.name.is_empty() {
2021 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
2022 }
2023 if !self.data_type.is_empty() {
2024 size += 1u32 + ::buffa::types::string_encoded_len(&self.data_type) as u32;
2025 }
2026 if self.nullable {
2027 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
2028 }
2029 size += self.__buffa_unknown_fields.encoded_len() as u32;
2030 size
2031 }
2032 fn write_to(
2033 &self,
2034 _cache: &mut ::buffa::SizeCache,
2035 buf: &mut impl ::buffa::bytes::BufMut,
2036 ) {
2037 #[allow(unused_imports)]
2038 use ::buffa::Enumeration as _;
2039 if !self.name.is_empty() {
2040 ::buffa::encoding::Tag::new(
2041 1u32,
2042 ::buffa::encoding::WireType::LengthDelimited,
2043 )
2044 .encode(buf);
2045 ::buffa::types::encode_string(&self.name, buf);
2046 }
2047 if !self.data_type.is_empty() {
2048 ::buffa::encoding::Tag::new(
2049 2u32,
2050 ::buffa::encoding::WireType::LengthDelimited,
2051 )
2052 .encode(buf);
2053 ::buffa::types::encode_string(&self.data_type, buf);
2054 }
2055 if self.nullable {
2056 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
2057 .encode(buf);
2058 ::buffa::types::encode_bool(self.nullable, buf);
2059 }
2060 self.__buffa_unknown_fields.write_to(buf);
2061 }
2062 fn merge_field(
2063 &mut self,
2064 tag: ::buffa::encoding::Tag,
2065 buf: &mut impl ::buffa::bytes::Buf,
2066 depth: u32,
2067 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2068 #[allow(unused_imports)]
2069 use ::buffa::bytes::Buf as _;
2070 #[allow(unused_imports)]
2071 use ::buffa::Enumeration as _;
2072 match tag.field_number() {
2073 1u32 => {
2074 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2075 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2076 field_number: 1u32,
2077 expected: 2u8,
2078 actual: tag.wire_type() as u8,
2079 });
2080 }
2081 ::buffa::types::merge_string(&mut self.name, buf)?;
2082 }
2083 2u32 => {
2084 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2085 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2086 field_number: 2u32,
2087 expected: 2u8,
2088 actual: tag.wire_type() as u8,
2089 });
2090 }
2091 ::buffa::types::merge_string(&mut self.data_type, buf)?;
2092 }
2093 3u32 => {
2094 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2095 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2096 field_number: 3u32,
2097 expected: 0u8,
2098 actual: tag.wire_type() as u8,
2099 });
2100 }
2101 self.nullable = ::buffa::types::decode_bool(buf)?;
2102 }
2103 _ => {
2104 self.__buffa_unknown_fields
2105 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2106 }
2107 }
2108 ::core::result::Result::Ok(())
2109 }
2110 fn clear(&mut self) {
2111 self.name.clear();
2112 self.data_type.clear();
2113 self.nullable = false;
2114 self.__buffa_unknown_fields.clear();
2115 }
2116}
2117impl ::buffa::ExtensionSet for Column {
2118 const PROTO_FQN: &'static str = "sql.v1.Column";
2119 fn unknown_fields(&self) -> &::buffa::UnknownFields {
2120 &self.__buffa_unknown_fields
2121 }
2122 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
2123 &mut self.__buffa_unknown_fields
2124 }
2125}
2126impl ::buffa::json_helpers::ProtoElemJson for Column {
2127 fn serialize_proto_json<S: ::serde::Serializer>(
2128 v: &Self,
2129 s: S,
2130 ) -> ::core::result::Result<S::Ok, S::Error> {
2131 ::serde::Serialize::serialize(v, s)
2132 }
2133 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
2134 d: D,
2135 ) -> ::core::result::Result<Self, D::Error> {
2136 <Self as ::serde::Deserialize>::deserialize(d)
2137 }
2138}
2139#[doc(hidden)]
2140pub const __COLUMN_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
2141 type_url: "type.googleapis.com/sql.v1.Column",
2142 to_json: ::buffa::type_registry::any_to_json::<Column>,
2143 from_json: ::buffa::type_registry::any_from_json::<Column>,
2144 is_wkt: false,
2145};
2146#[derive(Clone, PartialEq, Default)]
2148#[derive(::serde::Serialize, ::serde::Deserialize)]
2149#[serde(default)]
2150pub struct Index {
2151 #[serde(
2153 rename = "name",
2154 with = "::buffa::json_helpers::proto_string",
2155 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2156 )]
2157 pub name: ::buffa::alloc::string::String,
2158 #[serde(
2160 rename = "layout",
2161 with = "::buffa::json_helpers::proto_enum",
2162 skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
2163 )]
2164 pub layout: ::buffa::EnumValue<IndexLayout>,
2165 #[serde(
2169 rename = "keyColumns",
2170 alias = "key_columns",
2171 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
2172 deserialize_with = "::buffa::json_helpers::null_as_default"
2173 )]
2174 pub key_columns: ::buffa::alloc::vec::Vec<u32>,
2175 #[serde(
2180 rename = "coverColumns",
2181 alias = "cover_columns",
2182 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
2183 deserialize_with = "::buffa::json_helpers::null_as_default"
2184 )]
2185 pub cover_columns: ::buffa::alloc::vec::Vec<u32>,
2186 #[serde(skip)]
2187 #[doc(hidden)]
2188 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2189}
2190impl ::core::fmt::Debug for Index {
2191 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2192 f.debug_struct("Index")
2193 .field("name", &self.name)
2194 .field("layout", &self.layout)
2195 .field("key_columns", &self.key_columns)
2196 .field("cover_columns", &self.cover_columns)
2197 .finish()
2198 }
2199}
2200impl Index {
2201 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Index";
2206}
2207impl ::buffa::DefaultInstance for Index {
2208 fn default_instance() -> &'static Self {
2209 static VALUE: ::buffa::__private::OnceBox<Index> = ::buffa::__private::OnceBox::new();
2210 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2211 }
2212}
2213impl ::buffa::MessageName for Index {
2214 const PACKAGE: &'static str = "sql.v1";
2215 const NAME: &'static str = "Index";
2216 const FULL_NAME: &'static str = "sql.v1.Index";
2217 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Index";
2218}
2219impl ::buffa::Message for Index {
2220 #[allow(clippy::let_and_return)]
2226 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
2227 #[allow(unused_imports)]
2228 use ::buffa::Enumeration as _;
2229 let mut size = 0u32;
2230 if !self.name.is_empty() {
2231 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
2232 }
2233 {
2234 let val = self.layout.to_i32();
2235 if val != 0 {
2236 size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
2237 }
2238 }
2239 if !self.key_columns.is_empty() {
2240 let payload: u32 = self
2241 .key_columns
2242 .iter()
2243 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
2244 .sum::<u32>();
2245 size
2246 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
2247 }
2248 if !self.cover_columns.is_empty() {
2249 let payload: u32 = self
2250 .cover_columns
2251 .iter()
2252 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
2253 .sum::<u32>();
2254 size
2255 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
2256 }
2257 size += self.__buffa_unknown_fields.encoded_len() as u32;
2258 size
2259 }
2260 fn write_to(
2261 &self,
2262 _cache: &mut ::buffa::SizeCache,
2263 buf: &mut impl ::buffa::bytes::BufMut,
2264 ) {
2265 #[allow(unused_imports)]
2266 use ::buffa::Enumeration as _;
2267 if !self.name.is_empty() {
2268 ::buffa::encoding::Tag::new(
2269 1u32,
2270 ::buffa::encoding::WireType::LengthDelimited,
2271 )
2272 .encode(buf);
2273 ::buffa::types::encode_string(&self.name, buf);
2274 }
2275 {
2276 let val = self.layout.to_i32();
2277 if val != 0 {
2278 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
2279 .encode(buf);
2280 ::buffa::types::encode_int32(val, buf);
2281 }
2282 }
2283 if !self.key_columns.is_empty() {
2284 let payload: u32 = self
2285 .key_columns
2286 .iter()
2287 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
2288 .sum::<u32>();
2289 ::buffa::encoding::Tag::new(
2290 3u32,
2291 ::buffa::encoding::WireType::LengthDelimited,
2292 )
2293 .encode(buf);
2294 ::buffa::encoding::encode_varint(payload as u64, buf);
2295 for &v in &self.key_columns {
2296 ::buffa::types::encode_uint32(v, buf);
2297 }
2298 }
2299 if !self.cover_columns.is_empty() {
2300 let payload: u32 = self
2301 .cover_columns
2302 .iter()
2303 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
2304 .sum::<u32>();
2305 ::buffa::encoding::Tag::new(
2306 4u32,
2307 ::buffa::encoding::WireType::LengthDelimited,
2308 )
2309 .encode(buf);
2310 ::buffa::encoding::encode_varint(payload as u64, buf);
2311 for &v in &self.cover_columns {
2312 ::buffa::types::encode_uint32(v, buf);
2313 }
2314 }
2315 self.__buffa_unknown_fields.write_to(buf);
2316 }
2317 fn merge_field(
2318 &mut self,
2319 tag: ::buffa::encoding::Tag,
2320 buf: &mut impl ::buffa::bytes::Buf,
2321 depth: u32,
2322 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2323 #[allow(unused_imports)]
2324 use ::buffa::bytes::Buf as _;
2325 #[allow(unused_imports)]
2326 use ::buffa::Enumeration as _;
2327 match tag.field_number() {
2328 1u32 => {
2329 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2330 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2331 field_number: 1u32,
2332 expected: 2u8,
2333 actual: tag.wire_type() as u8,
2334 });
2335 }
2336 ::buffa::types::merge_string(&mut self.name, buf)?;
2337 }
2338 2u32 => {
2339 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2340 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2341 field_number: 2u32,
2342 expected: 0u8,
2343 actual: tag.wire_type() as u8,
2344 });
2345 }
2346 self.layout = ::buffa::EnumValue::from(
2347 ::buffa::types::decode_int32(buf)?,
2348 );
2349 }
2350 3u32 => {
2351 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
2352 let len = ::buffa::encoding::decode_varint(buf)?;
2353 let len = usize::try_from(len)
2354 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
2355 if buf.remaining() < len {
2356 return ::core::result::Result::Err(
2357 ::buffa::DecodeError::UnexpectedEof,
2358 );
2359 }
2360 self.key_columns.reserve(len);
2361 let mut limited = buf.take(len);
2362 while limited.has_remaining() {
2363 self.key_columns
2364 .push(::buffa::types::decode_uint32(&mut limited)?);
2365 }
2366 let leftover = limited.remaining();
2367 if leftover > 0 {
2368 limited.advance(leftover);
2369 }
2370 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
2371 self.key_columns.push(::buffa::types::decode_uint32(buf)?);
2372 } else {
2373 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2374 field_number: 3u32,
2375 expected: 2u8,
2376 actual: tag.wire_type() as u8,
2377 });
2378 }
2379 }
2380 4u32 => {
2381 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
2382 let len = ::buffa::encoding::decode_varint(buf)?;
2383 let len = usize::try_from(len)
2384 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
2385 if buf.remaining() < len {
2386 return ::core::result::Result::Err(
2387 ::buffa::DecodeError::UnexpectedEof,
2388 );
2389 }
2390 self.cover_columns.reserve(len);
2391 let mut limited = buf.take(len);
2392 while limited.has_remaining() {
2393 self.cover_columns
2394 .push(::buffa::types::decode_uint32(&mut limited)?);
2395 }
2396 let leftover = limited.remaining();
2397 if leftover > 0 {
2398 limited.advance(leftover);
2399 }
2400 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
2401 self.cover_columns.push(::buffa::types::decode_uint32(buf)?);
2402 } else {
2403 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2404 field_number: 4u32,
2405 expected: 2u8,
2406 actual: tag.wire_type() as u8,
2407 });
2408 }
2409 }
2410 _ => {
2411 self.__buffa_unknown_fields
2412 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2413 }
2414 }
2415 ::core::result::Result::Ok(())
2416 }
2417 fn clear(&mut self) {
2418 self.name.clear();
2419 self.layout = ::buffa::EnumValue::from(0);
2420 self.key_columns.clear();
2421 self.cover_columns.clear();
2422 self.__buffa_unknown_fields.clear();
2423 }
2424}
2425impl ::buffa::ExtensionSet for Index {
2426 const PROTO_FQN: &'static str = "sql.v1.Index";
2427 fn unknown_fields(&self) -> &::buffa::UnknownFields {
2428 &self.__buffa_unknown_fields
2429 }
2430 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
2431 &mut self.__buffa_unknown_fields
2432 }
2433}
2434impl ::buffa::json_helpers::ProtoElemJson for Index {
2435 fn serialize_proto_json<S: ::serde::Serializer>(
2436 v: &Self,
2437 s: S,
2438 ) -> ::core::result::Result<S::Ok, S::Error> {
2439 ::serde::Serialize::serialize(v, s)
2440 }
2441 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
2442 d: D,
2443 ) -> ::core::result::Result<Self, D::Error> {
2444 <Self as ::serde::Deserialize>::deserialize(d)
2445 }
2446}
2447#[doc(hidden)]
2448pub const __INDEX_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
2449 type_url: "type.googleapis.com/sql.v1.Index",
2450 to_json: ::buffa::type_registry::any_to_json::<Index>,
2451 from_json: ::buffa::type_registry::any_from_json::<Index>,
2452 is_wkt: false,
2453};
2454#[derive(Clone, PartialEq, Default)]
2456#[derive(::serde::Serialize, ::serde::Deserialize)]
2457#[serde(default)]
2458pub struct QueryRequest {
2459 #[serde(
2461 rename = "sql",
2462 with = "::buffa::json_helpers::proto_string",
2463 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2464 )]
2465 pub sql: ::buffa::alloc::string::String,
2466 #[serde(skip)]
2467 #[doc(hidden)]
2468 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2469}
2470impl ::core::fmt::Debug for QueryRequest {
2471 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2472 f.debug_struct("QueryRequest").field("sql", &self.sql).finish()
2473 }
2474}
2475impl QueryRequest {
2476 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryRequest";
2481}
2482impl ::buffa::DefaultInstance for QueryRequest {
2483 fn default_instance() -> &'static Self {
2484 static VALUE: ::buffa::__private::OnceBox<QueryRequest> = ::buffa::__private::OnceBox::new();
2485 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2486 }
2487}
2488impl ::buffa::MessageName for QueryRequest {
2489 const PACKAGE: &'static str = "sql.v1";
2490 const NAME: &'static str = "QueryRequest";
2491 const FULL_NAME: &'static str = "sql.v1.QueryRequest";
2492 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryRequest";
2493}
2494impl ::buffa::Message for QueryRequest {
2495 #[allow(clippy::let_and_return)]
2501 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
2502 #[allow(unused_imports)]
2503 use ::buffa::Enumeration as _;
2504 let mut size = 0u32;
2505 if !self.sql.is_empty() {
2506 size += 1u32 + ::buffa::types::string_encoded_len(&self.sql) as u32;
2507 }
2508 size += self.__buffa_unknown_fields.encoded_len() as u32;
2509 size
2510 }
2511 fn write_to(
2512 &self,
2513 _cache: &mut ::buffa::SizeCache,
2514 buf: &mut impl ::buffa::bytes::BufMut,
2515 ) {
2516 #[allow(unused_imports)]
2517 use ::buffa::Enumeration as _;
2518 if !self.sql.is_empty() {
2519 ::buffa::encoding::Tag::new(
2520 1u32,
2521 ::buffa::encoding::WireType::LengthDelimited,
2522 )
2523 .encode(buf);
2524 ::buffa::types::encode_string(&self.sql, buf);
2525 }
2526 self.__buffa_unknown_fields.write_to(buf);
2527 }
2528 fn merge_field(
2529 &mut self,
2530 tag: ::buffa::encoding::Tag,
2531 buf: &mut impl ::buffa::bytes::Buf,
2532 depth: u32,
2533 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2534 #[allow(unused_imports)]
2535 use ::buffa::bytes::Buf as _;
2536 #[allow(unused_imports)]
2537 use ::buffa::Enumeration as _;
2538 match tag.field_number() {
2539 1u32 => {
2540 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2541 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2542 field_number: 1u32,
2543 expected: 2u8,
2544 actual: tag.wire_type() as u8,
2545 });
2546 }
2547 ::buffa::types::merge_string(&mut self.sql, buf)?;
2548 }
2549 _ => {
2550 self.__buffa_unknown_fields
2551 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2552 }
2553 }
2554 ::core::result::Result::Ok(())
2555 }
2556 fn clear(&mut self) {
2557 self.sql.clear();
2558 self.__buffa_unknown_fields.clear();
2559 }
2560}
2561impl ::buffa::ExtensionSet for QueryRequest {
2562 const PROTO_FQN: &'static str = "sql.v1.QueryRequest";
2563 fn unknown_fields(&self) -> &::buffa::UnknownFields {
2564 &self.__buffa_unknown_fields
2565 }
2566 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
2567 &mut self.__buffa_unknown_fields
2568 }
2569}
2570impl ::buffa::json_helpers::ProtoElemJson for QueryRequest {
2571 fn serialize_proto_json<S: ::serde::Serializer>(
2572 v: &Self,
2573 s: S,
2574 ) -> ::core::result::Result<S::Ok, S::Error> {
2575 ::serde::Serialize::serialize(v, s)
2576 }
2577 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
2578 d: D,
2579 ) -> ::core::result::Result<Self, D::Error> {
2580 <Self as ::serde::Deserialize>::deserialize(d)
2581 }
2582}
2583#[doc(hidden)]
2584pub const __QUERY_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
2585 type_url: "type.googleapis.com/sql.v1.QueryRequest",
2586 to_json: ::buffa::type_registry::any_to_json::<QueryRequest>,
2587 from_json: ::buffa::type_registry::any_from_json::<QueryRequest>,
2588 is_wkt: false,
2589};
2590#[derive(Clone, PartialEq, Default)]
2592#[derive(::serde::Serialize, ::serde::Deserialize)]
2593#[serde(default)]
2594pub struct QueryResponse {
2595 #[serde(
2597 rename = "column",
2598 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
2599 deserialize_with = "::buffa::json_helpers::null_as_default"
2600 )]
2601 pub column: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
2602 #[serde(
2604 rename = "rows",
2605 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
2606 deserialize_with = "::buffa::json_helpers::null_as_default"
2607 )]
2608 pub rows: ::buffa::alloc::vec::Vec<Row>,
2609 #[serde(skip)]
2610 #[doc(hidden)]
2611 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2612}
2613impl ::core::fmt::Debug for QueryResponse {
2614 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2615 f.debug_struct("QueryResponse")
2616 .field("column", &self.column)
2617 .field("rows", &self.rows)
2618 .finish()
2619 }
2620}
2621impl QueryResponse {
2622 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryResponse";
2627}
2628impl ::buffa::DefaultInstance for QueryResponse {
2629 fn default_instance() -> &'static Self {
2630 static VALUE: ::buffa::__private::OnceBox<QueryResponse> = ::buffa::__private::OnceBox::new();
2631 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2632 }
2633}
2634impl ::buffa::MessageName for QueryResponse {
2635 const PACKAGE: &'static str = "sql.v1";
2636 const NAME: &'static str = "QueryResponse";
2637 const FULL_NAME: &'static str = "sql.v1.QueryResponse";
2638 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryResponse";
2639}
2640impl ::buffa::Message for QueryResponse {
2641 #[allow(clippy::let_and_return)]
2647 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
2648 #[allow(unused_imports)]
2649 use ::buffa::Enumeration as _;
2650 let mut size = 0u32;
2651 for v in &self.column {
2652 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
2653 }
2654 for v in &self.rows {
2655 let __slot = __cache.reserve();
2656 let inner_size = v.compute_size(__cache);
2657 __cache.set(__slot, inner_size);
2658 size
2659 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
2660 + inner_size;
2661 }
2662 size += self.__buffa_unknown_fields.encoded_len() as u32;
2663 size
2664 }
2665 fn write_to(
2666 &self,
2667 __cache: &mut ::buffa::SizeCache,
2668 buf: &mut impl ::buffa::bytes::BufMut,
2669 ) {
2670 #[allow(unused_imports)]
2671 use ::buffa::Enumeration as _;
2672 for v in &self.column {
2673 ::buffa::encoding::Tag::new(
2674 1u32,
2675 ::buffa::encoding::WireType::LengthDelimited,
2676 )
2677 .encode(buf);
2678 ::buffa::types::encode_string(v, buf);
2679 }
2680 for v in &self.rows {
2681 ::buffa::encoding::Tag::new(
2682 2u32,
2683 ::buffa::encoding::WireType::LengthDelimited,
2684 )
2685 .encode(buf);
2686 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
2687 v.write_to(__cache, buf);
2688 }
2689 self.__buffa_unknown_fields.write_to(buf);
2690 }
2691 fn merge_field(
2692 &mut self,
2693 tag: ::buffa::encoding::Tag,
2694 buf: &mut impl ::buffa::bytes::Buf,
2695 depth: u32,
2696 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2697 #[allow(unused_imports)]
2698 use ::buffa::bytes::Buf as _;
2699 #[allow(unused_imports)]
2700 use ::buffa::Enumeration as _;
2701 match tag.field_number() {
2702 1u32 => {
2703 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2704 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2705 field_number: 1u32,
2706 expected: 2u8,
2707 actual: tag.wire_type() as u8,
2708 });
2709 }
2710 self.column.push(::buffa::types::decode_string(buf)?);
2711 }
2712 2u32 => {
2713 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2714 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2715 field_number: 2u32,
2716 expected: 2u8,
2717 actual: tag.wire_type() as u8,
2718 });
2719 }
2720 let mut elem = ::core::default::Default::default();
2721 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
2722 self.rows.push(elem);
2723 }
2724 _ => {
2725 self.__buffa_unknown_fields
2726 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2727 }
2728 }
2729 ::core::result::Result::Ok(())
2730 }
2731 fn clear(&mut self) {
2732 self.column.clear();
2733 self.rows.clear();
2734 self.__buffa_unknown_fields.clear();
2735 }
2736}
2737impl ::buffa::ExtensionSet for QueryResponse {
2738 const PROTO_FQN: &'static str = "sql.v1.QueryResponse";
2739 fn unknown_fields(&self) -> &::buffa::UnknownFields {
2740 &self.__buffa_unknown_fields
2741 }
2742 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
2743 &mut self.__buffa_unknown_fields
2744 }
2745}
2746impl ::buffa::json_helpers::ProtoElemJson for QueryResponse {
2747 fn serialize_proto_json<S: ::serde::Serializer>(
2748 v: &Self,
2749 s: S,
2750 ) -> ::core::result::Result<S::Ok, S::Error> {
2751 ::serde::Serialize::serialize(v, s)
2752 }
2753 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
2754 d: D,
2755 ) -> ::core::result::Result<Self, D::Error> {
2756 <Self as ::serde::Deserialize>::deserialize(d)
2757 }
2758}
2759#[doc(hidden)]
2760pub const __QUERY_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
2761 type_url: "type.googleapis.com/sql.v1.QueryResponse",
2762 to_json: ::buffa::type_registry::any_to_json::<QueryResponse>,
2763 from_json: ::buffa::type_registry::any_from_json::<QueryResponse>,
2764 is_wkt: false,
2765};
2766#[derive(Clone, PartialEq, Default)]
2768#[derive(::serde::Serialize, ::serde::Deserialize)]
2769#[serde(default)]
2770pub struct SubscribeRequest {
2771 #[serde(
2775 rename = "table",
2776 with = "::buffa::json_helpers::proto_string",
2777 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2778 )]
2779 pub table: ::buffa::alloc::string::String,
2780 #[serde(
2786 rename = "whereSql",
2787 alias = "where_sql",
2788 with = "::buffa::json_helpers::proto_string",
2789 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
2790 )]
2791 pub where_sql: ::buffa::alloc::string::String,
2792 #[serde(
2797 rename = "sinceSequenceNumber",
2798 alias = "since_sequence_number",
2799 with = "::buffa::json_helpers::opt_uint64",
2800 skip_serializing_if = "::core::option::Option::is_none"
2801 )]
2802 pub since_sequence_number: ::core::option::Option<u64>,
2803 #[serde(skip)]
2804 #[doc(hidden)]
2805 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2806}
2807impl ::core::fmt::Debug for SubscribeRequest {
2808 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2809 f.debug_struct("SubscribeRequest")
2810 .field("table", &self.table)
2811 .field("where_sql", &self.where_sql)
2812 .field("since_sequence_number", &self.since_sequence_number)
2813 .finish()
2814 }
2815}
2816impl SubscribeRequest {
2817 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeRequest";
2822}
2823impl SubscribeRequest {
2824 #[must_use = "with_* setters return `self` by value; assign or chain the result"]
2825 #[inline]
2826 pub fn with_since_sequence_number(mut self, value: u64) -> Self {
2828 self.since_sequence_number = Some(value);
2829 self
2830 }
2831}
2832impl ::buffa::DefaultInstance for SubscribeRequest {
2833 fn default_instance() -> &'static Self {
2834 static VALUE: ::buffa::__private::OnceBox<SubscribeRequest> = ::buffa::__private::OnceBox::new();
2835 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
2836 }
2837}
2838impl ::buffa::MessageName for SubscribeRequest {
2839 const PACKAGE: &'static str = "sql.v1";
2840 const NAME: &'static str = "SubscribeRequest";
2841 const FULL_NAME: &'static str = "sql.v1.SubscribeRequest";
2842 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeRequest";
2843}
2844impl ::buffa::Message for SubscribeRequest {
2845 #[allow(clippy::let_and_return)]
2851 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
2852 #[allow(unused_imports)]
2853 use ::buffa::Enumeration as _;
2854 let mut size = 0u32;
2855 if !self.table.is_empty() {
2856 size += 1u32 + ::buffa::types::string_encoded_len(&self.table) as u32;
2857 }
2858 if !self.where_sql.is_empty() {
2859 size += 1u32 + ::buffa::types::string_encoded_len(&self.where_sql) as u32;
2860 }
2861 if let Some(v) = self.since_sequence_number {
2862 size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
2863 }
2864 size += self.__buffa_unknown_fields.encoded_len() as u32;
2865 size
2866 }
2867 fn write_to(
2868 &self,
2869 _cache: &mut ::buffa::SizeCache,
2870 buf: &mut impl ::buffa::bytes::BufMut,
2871 ) {
2872 #[allow(unused_imports)]
2873 use ::buffa::Enumeration as _;
2874 if !self.table.is_empty() {
2875 ::buffa::encoding::Tag::new(
2876 1u32,
2877 ::buffa::encoding::WireType::LengthDelimited,
2878 )
2879 .encode(buf);
2880 ::buffa::types::encode_string(&self.table, buf);
2881 }
2882 if !self.where_sql.is_empty() {
2883 ::buffa::encoding::Tag::new(
2884 2u32,
2885 ::buffa::encoding::WireType::LengthDelimited,
2886 )
2887 .encode(buf);
2888 ::buffa::types::encode_string(&self.where_sql, buf);
2889 }
2890 if let Some(v) = self.since_sequence_number {
2891 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
2892 .encode(buf);
2893 ::buffa::types::encode_uint64(v, buf);
2894 }
2895 self.__buffa_unknown_fields.write_to(buf);
2896 }
2897 fn merge_field(
2898 &mut self,
2899 tag: ::buffa::encoding::Tag,
2900 buf: &mut impl ::buffa::bytes::Buf,
2901 depth: u32,
2902 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2903 #[allow(unused_imports)]
2904 use ::buffa::bytes::Buf as _;
2905 #[allow(unused_imports)]
2906 use ::buffa::Enumeration as _;
2907 match tag.field_number() {
2908 1u32 => {
2909 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2910 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2911 field_number: 1u32,
2912 expected: 2u8,
2913 actual: tag.wire_type() as u8,
2914 });
2915 }
2916 ::buffa::types::merge_string(&mut self.table, buf)?;
2917 }
2918 2u32 => {
2919 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2920 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2921 field_number: 2u32,
2922 expected: 2u8,
2923 actual: tag.wire_type() as u8,
2924 });
2925 }
2926 ::buffa::types::merge_string(&mut self.where_sql, buf)?;
2927 }
2928 3u32 => {
2929 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2930 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2931 field_number: 3u32,
2932 expected: 0u8,
2933 actual: tag.wire_type() as u8,
2934 });
2935 }
2936 self.since_sequence_number = ::core::option::Option::Some(
2937 ::buffa::types::decode_uint64(buf)?,
2938 );
2939 }
2940 _ => {
2941 self.__buffa_unknown_fields
2942 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2943 }
2944 }
2945 ::core::result::Result::Ok(())
2946 }
2947 fn clear(&mut self) {
2948 self.table.clear();
2949 self.where_sql.clear();
2950 self.since_sequence_number = ::core::option::Option::None;
2951 self.__buffa_unknown_fields.clear();
2952 }
2953}
2954impl ::buffa::ExtensionSet for SubscribeRequest {
2955 const PROTO_FQN: &'static str = "sql.v1.SubscribeRequest";
2956 fn unknown_fields(&self) -> &::buffa::UnknownFields {
2957 &self.__buffa_unknown_fields
2958 }
2959 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
2960 &mut self.__buffa_unknown_fields
2961 }
2962}
2963impl ::buffa::json_helpers::ProtoElemJson for SubscribeRequest {
2964 fn serialize_proto_json<S: ::serde::Serializer>(
2965 v: &Self,
2966 s: S,
2967 ) -> ::core::result::Result<S::Ok, S::Error> {
2968 ::serde::Serialize::serialize(v, s)
2969 }
2970 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
2971 d: D,
2972 ) -> ::core::result::Result<Self, D::Error> {
2973 <Self as ::serde::Deserialize>::deserialize(d)
2974 }
2975}
2976#[doc(hidden)]
2977pub const __SUBSCRIBE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
2978 type_url: "type.googleapis.com/sql.v1.SubscribeRequest",
2979 to_json: ::buffa::type_registry::any_to_json::<SubscribeRequest>,
2980 from_json: ::buffa::type_registry::any_from_json::<SubscribeRequest>,
2981 is_wkt: false,
2982};
2983#[derive(Clone, PartialEq, Default)]
2985#[derive(::serde::Serialize, ::serde::Deserialize)]
2986#[serde(default)]
2987pub struct SubscribeResponse {
2988 #[serde(
2993 rename = "sequenceNumber",
2994 alias = "sequence_number",
2995 with = "::buffa::json_helpers::uint64",
2996 skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
2997 )]
2998 pub sequence_number: u64,
2999 #[serde(
3003 rename = "column",
3004 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
3005 deserialize_with = "::buffa::json_helpers::null_as_default"
3006 )]
3007 pub column: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
3008 #[serde(
3013 rename = "rows",
3014 skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
3015 deserialize_with = "::buffa::json_helpers::null_as_default"
3016 )]
3017 pub rows: ::buffa::alloc::vec::Vec<Row>,
3018 #[serde(skip)]
3019 #[doc(hidden)]
3020 pub __buffa_unknown_fields: ::buffa::UnknownFields,
3021}
3022impl ::core::fmt::Debug for SubscribeResponse {
3023 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3024 f.debug_struct("SubscribeResponse")
3025 .field("sequence_number", &self.sequence_number)
3026 .field("column", &self.column)
3027 .field("rows", &self.rows)
3028 .finish()
3029 }
3030}
3031impl SubscribeResponse {
3032 pub const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeResponse";
3037}
3038impl ::buffa::DefaultInstance for SubscribeResponse {
3039 fn default_instance() -> &'static Self {
3040 static VALUE: ::buffa::__private::OnceBox<SubscribeResponse> = ::buffa::__private::OnceBox::new();
3041 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
3042 }
3043}
3044impl ::buffa::MessageName for SubscribeResponse {
3045 const PACKAGE: &'static str = "sql.v1";
3046 const NAME: &'static str = "SubscribeResponse";
3047 const FULL_NAME: &'static str = "sql.v1.SubscribeResponse";
3048 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeResponse";
3049}
3050impl ::buffa::Message for SubscribeResponse {
3051 #[allow(clippy::let_and_return)]
3057 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
3058 #[allow(unused_imports)]
3059 use ::buffa::Enumeration as _;
3060 let mut size = 0u32;
3061 if self.sequence_number != 0u64 {
3062 size
3063 += 1u32
3064 + ::buffa::types::uint64_encoded_len(self.sequence_number) as u32;
3065 }
3066 for v in &self.column {
3067 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
3068 }
3069 for v in &self.rows {
3070 let __slot = __cache.reserve();
3071 let inner_size = v.compute_size(__cache);
3072 __cache.set(__slot, inner_size);
3073 size
3074 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3075 + inner_size;
3076 }
3077 size += self.__buffa_unknown_fields.encoded_len() as u32;
3078 size
3079 }
3080 fn write_to(
3081 &self,
3082 __cache: &mut ::buffa::SizeCache,
3083 buf: &mut impl ::buffa::bytes::BufMut,
3084 ) {
3085 #[allow(unused_imports)]
3086 use ::buffa::Enumeration as _;
3087 if self.sequence_number != 0u64 {
3088 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
3089 .encode(buf);
3090 ::buffa::types::encode_uint64(self.sequence_number, buf);
3091 }
3092 for v in &self.column {
3093 ::buffa::encoding::Tag::new(
3094 2u32,
3095 ::buffa::encoding::WireType::LengthDelimited,
3096 )
3097 .encode(buf);
3098 ::buffa::types::encode_string(v, buf);
3099 }
3100 for v in &self.rows {
3101 ::buffa::encoding::Tag::new(
3102 3u32,
3103 ::buffa::encoding::WireType::LengthDelimited,
3104 )
3105 .encode(buf);
3106 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
3107 v.write_to(__cache, buf);
3108 }
3109 self.__buffa_unknown_fields.write_to(buf);
3110 }
3111 fn merge_field(
3112 &mut self,
3113 tag: ::buffa::encoding::Tag,
3114 buf: &mut impl ::buffa::bytes::Buf,
3115 depth: u32,
3116 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3117 #[allow(unused_imports)]
3118 use ::buffa::bytes::Buf as _;
3119 #[allow(unused_imports)]
3120 use ::buffa::Enumeration as _;
3121 match tag.field_number() {
3122 1u32 => {
3123 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3124 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3125 field_number: 1u32,
3126 expected: 0u8,
3127 actual: tag.wire_type() as u8,
3128 });
3129 }
3130 self.sequence_number = ::buffa::types::decode_uint64(buf)?;
3131 }
3132 2u32 => {
3133 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3134 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3135 field_number: 2u32,
3136 expected: 2u8,
3137 actual: tag.wire_type() as u8,
3138 });
3139 }
3140 self.column.push(::buffa::types::decode_string(buf)?);
3141 }
3142 3u32 => {
3143 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3144 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3145 field_number: 3u32,
3146 expected: 2u8,
3147 actual: tag.wire_type() as u8,
3148 });
3149 }
3150 let mut elem = ::core::default::Default::default();
3151 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
3152 self.rows.push(elem);
3153 }
3154 _ => {
3155 self.__buffa_unknown_fields
3156 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
3157 }
3158 }
3159 ::core::result::Result::Ok(())
3160 }
3161 fn clear(&mut self) {
3162 self.sequence_number = 0u64;
3163 self.column.clear();
3164 self.rows.clear();
3165 self.__buffa_unknown_fields.clear();
3166 }
3167}
3168impl ::buffa::ExtensionSet for SubscribeResponse {
3169 const PROTO_FQN: &'static str = "sql.v1.SubscribeResponse";
3170 fn unknown_fields(&self) -> &::buffa::UnknownFields {
3171 &self.__buffa_unknown_fields
3172 }
3173 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
3174 &mut self.__buffa_unknown_fields
3175 }
3176}
3177impl ::buffa::json_helpers::ProtoElemJson for SubscribeResponse {
3178 fn serialize_proto_json<S: ::serde::Serializer>(
3179 v: &Self,
3180 s: S,
3181 ) -> ::core::result::Result<S::Ok, S::Error> {
3182 ::serde::Serialize::serialize(v, s)
3183 }
3184 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
3185 d: D,
3186 ) -> ::core::result::Result<Self, D::Error> {
3187 <Self as ::serde::Deserialize>::deserialize(d)
3188 }
3189}
3190#[doc(hidden)]
3191pub const __SUBSCRIBE_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
3192 type_url: "type.googleapis.com/sql.v1.SubscribeResponse",
3193 to_json: ::buffa::type_registry::any_to_json::<SubscribeResponse>,
3194 from_json: ::buffa::type_registry::any_from_json::<SubscribeResponse>,
3195 is_wkt: false,
3196};
3197#[allow(
3198 non_camel_case_types,
3199 dead_code,
3200 unused_imports,
3201 unused_qualifications,
3202 clippy::derivable_impls,
3203 clippy::match_single_binding,
3204 clippy::uninlined_format_args,
3205 clippy::doc_lazy_continuation,
3206 clippy::module_inception
3207)]
3208pub mod __buffa {
3209 #[allow(unused_imports)]
3210 use super::*;
3211 pub mod view {
3212 #[allow(unused_imports)]
3213 use super::*;
3214 #[derive(Clone, Debug, Default)]
3216 pub struct RowView<'a> {
3217 pub cells: ::buffa::RepeatedView<
3219 'a,
3220 super::super::__buffa::view::CellView<'a>,
3221 >,
3222 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3223 }
3224 impl<'a> RowView<'a> {
3225 #[doc(hidden)]
3233 pub fn _decode_depth(
3234 buf: &'a [u8],
3235 depth: u32,
3236 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3237 let mut view = Self::default();
3238 view._merge_into_view(buf, depth)?;
3239 ::core::result::Result::Ok(view)
3240 }
3241 #[doc(hidden)]
3249 pub fn _merge_into_view(
3250 &mut self,
3251 buf: &'a [u8],
3252 depth: u32,
3253 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3254 let _ = depth;
3255 #[allow(unused_variables)]
3256 let view = self;
3257 let mut cur: &'a [u8] = buf;
3258 while !cur.is_empty() {
3259 let before_tag = cur;
3260 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
3261 match tag.field_number() {
3262 1u32 => {
3263 if tag.wire_type()
3264 != ::buffa::encoding::WireType::LengthDelimited
3265 {
3266 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3267 field_number: 1u32,
3268 expected: 2u8,
3269 actual: tag.wire_type() as u8,
3270 });
3271 }
3272 if depth == 0 {
3273 return Err(::buffa::DecodeError::RecursionLimitExceeded);
3274 }
3275 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3276 view.cells
3277 .push(
3278 super::super::__buffa::view::CellView::_decode_depth(
3279 sub,
3280 depth - 1,
3281 )?,
3282 );
3283 }
3284 _ => {
3285 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
3286 let span_len = before_tag.len() - cur.len();
3287 view.__buffa_unknown_fields
3288 .push_raw(&before_tag[..span_len]);
3289 }
3290 }
3291 }
3292 ::core::result::Result::Ok(())
3293 }
3294 }
3295 impl<'a> ::buffa::MessageView<'a> for RowView<'a> {
3296 type Owned = super::super::Row;
3297 fn decode_view(
3298 buf: &'a [u8],
3299 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3300 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
3301 }
3302 fn decode_view_with_limit(
3303 buf: &'a [u8],
3304 depth: u32,
3305 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3306 Self::_decode_depth(buf, depth)
3307 }
3308 fn to_owned_message(&self) -> super::super::Row {
3309 self.to_owned_from_source(None)
3310 }
3311 #[allow(clippy::useless_conversion, clippy::needless_update)]
3312 fn to_owned_from_source(
3313 &self,
3314 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
3315 ) -> super::super::Row {
3316 #[allow(unused_imports)]
3317 use ::buffa::alloc::string::ToString as _;
3318 let _ = __buffa_src;
3319 super::super::Row {
3320 cells: self
3321 .cells
3322 .iter()
3323 .map(|v| v.to_owned_from_source(__buffa_src))
3324 .collect(),
3325 __buffa_unknown_fields: self
3326 .__buffa_unknown_fields
3327 .to_owned()
3328 .unwrap_or_default()
3329 .into(),
3330 ..::core::default::Default::default()
3331 }
3332 }
3333 }
3334 impl<'a> ::buffa::ViewEncode<'a> for RowView<'a> {
3335 #[allow(clippy::needless_borrow, clippy::let_and_return)]
3336 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
3337 #[allow(unused_imports)]
3338 use ::buffa::Enumeration as _;
3339 let mut size = 0u32;
3340 for v in &self.cells {
3341 let __slot = __cache.reserve();
3342 let inner_size = v.compute_size(__cache);
3343 __cache.set(__slot, inner_size);
3344 size
3345 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3346 + inner_size;
3347 }
3348 size += self.__buffa_unknown_fields.encoded_len() as u32;
3349 size
3350 }
3351 #[allow(clippy::needless_borrow)]
3352 fn write_to(
3353 &self,
3354 __cache: &mut ::buffa::SizeCache,
3355 buf: &mut impl ::buffa::bytes::BufMut,
3356 ) {
3357 #[allow(unused_imports)]
3358 use ::buffa::Enumeration as _;
3359 for v in &self.cells {
3360 ::buffa::encoding::Tag::new(
3361 1u32,
3362 ::buffa::encoding::WireType::LengthDelimited,
3363 )
3364 .encode(buf);
3365 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
3366 v.write_to(__cache, buf);
3367 }
3368 self.__buffa_unknown_fields.write_to(buf);
3369 }
3370 }
3371 impl<'__a> ::serde::Serialize for RowView<'__a> {
3383 fn serialize<__S: ::serde::Serializer>(
3384 &self,
3385 __s: __S,
3386 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3387 use ::serde::ser::SerializeMap as _;
3388 let mut __map = __s.serialize_map(::core::option::Option::None)?;
3389 if !self.cells.is_empty() {
3390 __map.serialize_entry("cells", &*self.cells)?;
3391 }
3392 __map.end()
3393 }
3394 }
3395 impl<'a> ::buffa::MessageName for RowView<'a> {
3396 const PACKAGE: &'static str = "sql.v1";
3397 const NAME: &'static str = "Row";
3398 const FULL_NAME: &'static str = "sql.v1.Row";
3399 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Row";
3400 }
3401 impl<'v> ::buffa::DefaultViewInstance for RowView<'v> {
3402 fn default_view_instance<'a>() -> &'a Self
3403 where
3404 Self: 'a,
3405 {
3406 static VALUE: ::buffa::__private::OnceBox<RowView<'static>> = ::buffa::__private::OnceBox::new();
3407 VALUE
3408 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
3409 <RowView<'static>>::default(),
3410 ))
3411 }
3412 }
3413 impl ::buffa::ViewReborrow for RowView<'static> {
3414 type Reborrowed<'b> = RowView<'b>;
3415 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
3416 this
3417 }
3418 }
3419 #[derive(Clone, Debug, Default)]
3422 pub struct NullView<'a> {
3423 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3424 }
3425 impl<'a> NullView<'a> {
3426 #[doc(hidden)]
3434 pub fn _decode_depth(
3435 buf: &'a [u8],
3436 depth: u32,
3437 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3438 let mut view = Self::default();
3439 view._merge_into_view(buf, depth)?;
3440 ::core::result::Result::Ok(view)
3441 }
3442 #[doc(hidden)]
3450 pub fn _merge_into_view(
3451 &mut self,
3452 buf: &'a [u8],
3453 depth: u32,
3454 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3455 let _ = depth;
3456 #[allow(unused_variables)]
3457 let view = self;
3458 let mut cur: &'a [u8] = buf;
3459 while !cur.is_empty() {
3460 let before_tag = cur;
3461 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
3462 match tag.field_number() {
3463 _ => {
3464 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
3465 let span_len = before_tag.len() - cur.len();
3466 view.__buffa_unknown_fields
3467 .push_raw(&before_tag[..span_len]);
3468 }
3469 }
3470 }
3471 ::core::result::Result::Ok(())
3472 }
3473 }
3474 impl<'a> ::buffa::MessageView<'a> for NullView<'a> {
3475 type Owned = super::super::Null;
3476 fn decode_view(
3477 buf: &'a [u8],
3478 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3479 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
3480 }
3481 fn decode_view_with_limit(
3482 buf: &'a [u8],
3483 depth: u32,
3484 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3485 Self::_decode_depth(buf, depth)
3486 }
3487 fn to_owned_message(&self) -> super::super::Null {
3488 self.to_owned_from_source(None)
3489 }
3490 #[allow(clippy::useless_conversion, clippy::needless_update)]
3491 fn to_owned_from_source(
3492 &self,
3493 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
3494 ) -> super::super::Null {
3495 #[allow(unused_imports)]
3496 use ::buffa::alloc::string::ToString as _;
3497 let _ = __buffa_src;
3498 super::super::Null {
3499 __buffa_unknown_fields: self
3500 .__buffa_unknown_fields
3501 .to_owned()
3502 .unwrap_or_default()
3503 .into(),
3504 ..::core::default::Default::default()
3505 }
3506 }
3507 }
3508 impl<'a> ::buffa::ViewEncode<'a> for NullView<'a> {
3509 #[allow(clippy::needless_borrow, clippy::let_and_return)]
3510 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
3511 #[allow(unused_imports)]
3512 use ::buffa::Enumeration as _;
3513 let mut size = 0u32;
3514 size += self.__buffa_unknown_fields.encoded_len() as u32;
3515 size
3516 }
3517 #[allow(clippy::needless_borrow)]
3518 fn write_to(
3519 &self,
3520 _cache: &mut ::buffa::SizeCache,
3521 buf: &mut impl ::buffa::bytes::BufMut,
3522 ) {
3523 #[allow(unused_imports)]
3524 use ::buffa::Enumeration as _;
3525 self.__buffa_unknown_fields.write_to(buf);
3526 }
3527 }
3528 impl<'__a> ::serde::Serialize for NullView<'__a> {
3540 fn serialize<__S: ::serde::Serializer>(
3541 &self,
3542 __s: __S,
3543 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3544 use ::serde::ser::SerializeMap as _;
3545 let mut __map = __s.serialize_map(::core::option::Option::None)?;
3546 __map.end()
3547 }
3548 }
3549 impl<'a> ::buffa::MessageName for NullView<'a> {
3550 const PACKAGE: &'static str = "sql.v1";
3551 const NAME: &'static str = "Null";
3552 const FULL_NAME: &'static str = "sql.v1.Null";
3553 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Null";
3554 }
3555 impl<'v> ::buffa::DefaultViewInstance for NullView<'v> {
3556 fn default_view_instance<'a>() -> &'a Self
3557 where
3558 Self: 'a,
3559 {
3560 static VALUE: ::buffa::__private::OnceBox<NullView<'static>> = ::buffa::__private::OnceBox::new();
3561 VALUE
3562 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
3563 <NullView<'static>>::default(),
3564 ))
3565 }
3566 }
3567 impl ::buffa::ViewReborrow for NullView<'static> {
3568 type Reborrowed<'b> = NullView<'b>;
3569 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
3570 this
3571 }
3572 }
3573 #[derive(Clone, Debug, Default)]
3576 pub struct ListValueView<'a> {
3577 pub elements: ::buffa::RepeatedView<
3579 'a,
3580 super::super::__buffa::view::CellView<'a>,
3581 >,
3582 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3583 }
3584 impl<'a> ListValueView<'a> {
3585 #[doc(hidden)]
3593 pub fn _decode_depth(
3594 buf: &'a [u8],
3595 depth: u32,
3596 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3597 let mut view = Self::default();
3598 view._merge_into_view(buf, depth)?;
3599 ::core::result::Result::Ok(view)
3600 }
3601 #[doc(hidden)]
3609 pub fn _merge_into_view(
3610 &mut self,
3611 buf: &'a [u8],
3612 depth: u32,
3613 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3614 let _ = depth;
3615 #[allow(unused_variables)]
3616 let view = self;
3617 let mut cur: &'a [u8] = buf;
3618 while !cur.is_empty() {
3619 let before_tag = cur;
3620 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
3621 match tag.field_number() {
3622 1u32 => {
3623 if tag.wire_type()
3624 != ::buffa::encoding::WireType::LengthDelimited
3625 {
3626 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3627 field_number: 1u32,
3628 expected: 2u8,
3629 actual: tag.wire_type() as u8,
3630 });
3631 }
3632 if depth == 0 {
3633 return Err(::buffa::DecodeError::RecursionLimitExceeded);
3634 }
3635 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3636 view.elements
3637 .push(
3638 super::super::__buffa::view::CellView::_decode_depth(
3639 sub,
3640 depth - 1,
3641 )?,
3642 );
3643 }
3644 _ => {
3645 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
3646 let span_len = before_tag.len() - cur.len();
3647 view.__buffa_unknown_fields
3648 .push_raw(&before_tag[..span_len]);
3649 }
3650 }
3651 }
3652 ::core::result::Result::Ok(())
3653 }
3654 }
3655 impl<'a> ::buffa::MessageView<'a> for ListValueView<'a> {
3656 type Owned = super::super::ListValue;
3657 fn decode_view(
3658 buf: &'a [u8],
3659 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3660 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
3661 }
3662 fn decode_view_with_limit(
3663 buf: &'a [u8],
3664 depth: u32,
3665 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3666 Self::_decode_depth(buf, depth)
3667 }
3668 fn to_owned_message(&self) -> super::super::ListValue {
3669 self.to_owned_from_source(None)
3670 }
3671 #[allow(clippy::useless_conversion, clippy::needless_update)]
3672 fn to_owned_from_source(
3673 &self,
3674 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
3675 ) -> super::super::ListValue {
3676 #[allow(unused_imports)]
3677 use ::buffa::alloc::string::ToString as _;
3678 let _ = __buffa_src;
3679 super::super::ListValue {
3680 elements: self
3681 .elements
3682 .iter()
3683 .map(|v| v.to_owned_from_source(__buffa_src))
3684 .collect(),
3685 __buffa_unknown_fields: self
3686 .__buffa_unknown_fields
3687 .to_owned()
3688 .unwrap_or_default()
3689 .into(),
3690 ..::core::default::Default::default()
3691 }
3692 }
3693 }
3694 impl<'a> ::buffa::ViewEncode<'a> for ListValueView<'a> {
3695 #[allow(clippy::needless_borrow, clippy::let_and_return)]
3696 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
3697 #[allow(unused_imports)]
3698 use ::buffa::Enumeration as _;
3699 let mut size = 0u32;
3700 for v in &self.elements {
3701 let __slot = __cache.reserve();
3702 let inner_size = v.compute_size(__cache);
3703 __cache.set(__slot, inner_size);
3704 size
3705 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3706 + inner_size;
3707 }
3708 size += self.__buffa_unknown_fields.encoded_len() as u32;
3709 size
3710 }
3711 #[allow(clippy::needless_borrow)]
3712 fn write_to(
3713 &self,
3714 __cache: &mut ::buffa::SizeCache,
3715 buf: &mut impl ::buffa::bytes::BufMut,
3716 ) {
3717 #[allow(unused_imports)]
3718 use ::buffa::Enumeration as _;
3719 for v in &self.elements {
3720 ::buffa::encoding::Tag::new(
3721 1u32,
3722 ::buffa::encoding::WireType::LengthDelimited,
3723 )
3724 .encode(buf);
3725 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
3726 v.write_to(__cache, buf);
3727 }
3728 self.__buffa_unknown_fields.write_to(buf);
3729 }
3730 }
3731 impl<'__a> ::serde::Serialize for ListValueView<'__a> {
3743 fn serialize<__S: ::serde::Serializer>(
3744 &self,
3745 __s: __S,
3746 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3747 use ::serde::ser::SerializeMap as _;
3748 let mut __map = __s.serialize_map(::core::option::Option::None)?;
3749 if !self.elements.is_empty() {
3750 __map.serialize_entry("elements", &*self.elements)?;
3751 }
3752 __map.end()
3753 }
3754 }
3755 impl<'a> ::buffa::MessageName for ListValueView<'a> {
3756 const PACKAGE: &'static str = "sql.v1";
3757 const NAME: &'static str = "ListValue";
3758 const FULL_NAME: &'static str = "sql.v1.ListValue";
3759 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.ListValue";
3760 }
3761 impl<'v> ::buffa::DefaultViewInstance for ListValueView<'v> {
3762 fn default_view_instance<'a>() -> &'a Self
3763 where
3764 Self: 'a,
3765 {
3766 static VALUE: ::buffa::__private::OnceBox<ListValueView<'static>> = ::buffa::__private::OnceBox::new();
3767 VALUE
3768 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
3769 <ListValueView<'static>>::default(),
3770 ))
3771 }
3772 }
3773 impl ::buffa::ViewReborrow for ListValueView<'static> {
3774 type Reborrowed<'b> = ListValueView<'b>;
3775 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
3776 this
3777 }
3778 }
3779 #[derive(Clone, Debug, Default)]
3783 pub struct CellView<'a> {
3784 pub kind: ::core::option::Option<
3785 super::super::__buffa::view::oneof::cell::Kind<'a>,
3786 >,
3787 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3788 }
3789 impl<'a> CellView<'a> {
3790 #[doc(hidden)]
3798 pub fn _decode_depth(
3799 buf: &'a [u8],
3800 depth: u32,
3801 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3802 let mut view = Self::default();
3803 view._merge_into_view(buf, depth)?;
3804 ::core::result::Result::Ok(view)
3805 }
3806 #[doc(hidden)]
3814 pub fn _merge_into_view(
3815 &mut self,
3816 buf: &'a [u8],
3817 depth: u32,
3818 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3819 let _ = depth;
3820 #[allow(unused_variables)]
3821 let view = self;
3822 let mut cur: &'a [u8] = buf;
3823 while !cur.is_empty() {
3824 let before_tag = cur;
3825 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
3826 match tag.field_number() {
3827 1u32 => {
3828 if tag.wire_type()
3829 != ::buffa::encoding::WireType::LengthDelimited
3830 {
3831 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3832 field_number: 1u32,
3833 expected: 2u8,
3834 actual: tag.wire_type() as u8,
3835 });
3836 }
3837 if depth == 0 {
3838 return Err(::buffa::DecodeError::RecursionLimitExceeded);
3839 }
3840 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3841 if let Some(
3842 super::super::__buffa::view::oneof::cell::Kind::NullValue(
3843 ref mut existing,
3844 ),
3845 ) = view.kind
3846 {
3847 existing._merge_into_view(sub, depth - 1)?;
3848 } else {
3849 view.kind = Some(
3850 super::super::__buffa::view::oneof::cell::Kind::NullValue(
3851 ::buffa::alloc::boxed::Box::new(
3852 super::super::__buffa::view::NullView::_decode_depth(
3853 sub,
3854 depth - 1,
3855 )?,
3856 ),
3857 ),
3858 );
3859 }
3860 }
3861 2u32 => {
3862 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3863 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3864 field_number: 2u32,
3865 expected: 0u8,
3866 actual: tag.wire_type() as u8,
3867 });
3868 }
3869 view.kind = Some(
3870 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
3871 ::buffa::types::decode_int64(&mut cur)?,
3872 ),
3873 );
3874 }
3875 3u32 => {
3876 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3877 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3878 field_number: 3u32,
3879 expected: 0u8,
3880 actual: tag.wire_type() as u8,
3881 });
3882 }
3883 view.kind = Some(
3884 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
3885 ::buffa::types::decode_uint64(&mut cur)?,
3886 ),
3887 );
3888 }
3889 4u32 => {
3890 if tag.wire_type() != ::buffa::encoding::WireType::Fixed64 {
3891 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3892 field_number: 4u32,
3893 expected: 1u8,
3894 actual: tag.wire_type() as u8,
3895 });
3896 }
3897 view.kind = Some(
3898 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
3899 ::buffa::types::decode_double(&mut cur)?,
3900 ),
3901 );
3902 }
3903 5u32 => {
3904 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3905 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3906 field_number: 5u32,
3907 expected: 0u8,
3908 actual: tag.wire_type() as u8,
3909 });
3910 }
3911 view.kind = Some(
3912 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
3913 ::buffa::types::decode_bool(&mut cur)?,
3914 ),
3915 );
3916 }
3917 6u32 => {
3918 if tag.wire_type()
3919 != ::buffa::encoding::WireType::LengthDelimited
3920 {
3921 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3922 field_number: 6u32,
3923 expected: 2u8,
3924 actual: tag.wire_type() as u8,
3925 });
3926 }
3927 view.kind = Some(
3928 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(
3929 ::buffa::types::borrow_str(&mut cur)?,
3930 ),
3931 );
3932 }
3933 7u32 => {
3934 if tag.wire_type()
3935 != ::buffa::encoding::WireType::LengthDelimited
3936 {
3937 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3938 field_number: 7u32,
3939 expected: 2u8,
3940 actual: tag.wire_type() as u8,
3941 });
3942 }
3943 view.kind = Some(
3944 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
3945 ::buffa::types::borrow_bytes(&mut cur)?,
3946 ),
3947 );
3948 }
3949 8u32 => {
3950 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3951 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3952 field_number: 8u32,
3953 expected: 0u8,
3954 actual: tag.wire_type() as u8,
3955 });
3956 }
3957 view.kind = Some(
3958 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
3959 ::buffa::types::decode_int32(&mut cur)?,
3960 ),
3961 );
3962 }
3963 9u32 => {
3964 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3965 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3966 field_number: 9u32,
3967 expected: 0u8,
3968 actual: tag.wire_type() as u8,
3969 });
3970 }
3971 view.kind = Some(
3972 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
3973 ::buffa::types::decode_int64(&mut cur)?,
3974 ),
3975 );
3976 }
3977 10u32 => {
3978 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3979 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3980 field_number: 10u32,
3981 expected: 0u8,
3982 actual: tag.wire_type() as u8,
3983 });
3984 }
3985 view.kind = Some(
3986 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
3987 ::buffa::types::decode_int64(&mut cur)?,
3988 ),
3989 );
3990 }
3991 11u32 => {
3992 if tag.wire_type()
3993 != ::buffa::encoding::WireType::LengthDelimited
3994 {
3995 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3996 field_number: 11u32,
3997 expected: 2u8,
3998 actual: tag.wire_type() as u8,
3999 });
4000 }
4001 view.kind = Some(
4002 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4003 ::buffa::types::borrow_bytes(&mut cur)?,
4004 ),
4005 );
4006 }
4007 12u32 => {
4008 if tag.wire_type()
4009 != ::buffa::encoding::WireType::LengthDelimited
4010 {
4011 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4012 field_number: 12u32,
4013 expected: 2u8,
4014 actual: tag.wire_type() as u8,
4015 });
4016 }
4017 view.kind = Some(
4018 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4019 ::buffa::types::borrow_bytes(&mut cur)?,
4020 ),
4021 );
4022 }
4023 13u32 => {
4024 if tag.wire_type()
4025 != ::buffa::encoding::WireType::LengthDelimited
4026 {
4027 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4028 field_number: 13u32,
4029 expected: 2u8,
4030 actual: tag.wire_type() as u8,
4031 });
4032 }
4033 if depth == 0 {
4034 return Err(::buffa::DecodeError::RecursionLimitExceeded);
4035 }
4036 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
4037 if let Some(
4038 super::super::__buffa::view::oneof::cell::Kind::ListValue(
4039 ref mut existing,
4040 ),
4041 ) = view.kind
4042 {
4043 existing._merge_into_view(sub, depth - 1)?;
4044 } else {
4045 view.kind = Some(
4046 super::super::__buffa::view::oneof::cell::Kind::ListValue(
4047 ::buffa::alloc::boxed::Box::new(
4048 super::super::__buffa::view::ListValueView::_decode_depth(
4049 sub,
4050 depth - 1,
4051 )?,
4052 ),
4053 ),
4054 );
4055 }
4056 }
4057 _ => {
4058 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
4059 let span_len = before_tag.len() - cur.len();
4060 view.__buffa_unknown_fields
4061 .push_raw(&before_tag[..span_len]);
4062 }
4063 }
4064 }
4065 ::core::result::Result::Ok(())
4066 }
4067 }
4068 impl<'a> ::buffa::MessageView<'a> for CellView<'a> {
4069 type Owned = super::super::Cell;
4070 fn decode_view(
4071 buf: &'a [u8],
4072 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4073 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
4074 }
4075 fn decode_view_with_limit(
4076 buf: &'a [u8],
4077 depth: u32,
4078 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4079 Self::_decode_depth(buf, depth)
4080 }
4081 fn to_owned_message(&self) -> super::super::Cell {
4082 self.to_owned_from_source(None)
4083 }
4084 #[allow(clippy::useless_conversion, clippy::needless_update)]
4085 fn to_owned_from_source(
4086 &self,
4087 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
4088 ) -> super::super::Cell {
4089 #[allow(unused_imports)]
4090 use ::buffa::alloc::string::ToString as _;
4091 let _ = __buffa_src;
4092 super::super::Cell {
4093 kind: self
4094 .kind
4095 .as_ref()
4096 .map(|v| match v {
4097 super::super::__buffa::view::oneof::cell::Kind::NullValue(
4098 v,
4099 ) => {
4100 super::super::__buffa::oneof::cell::Kind::NullValue(
4101 ::buffa::alloc::boxed::Box::new(
4102 v.to_owned_from_source(__buffa_src),
4103 ),
4104 )
4105 }
4106 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
4107 v,
4108 ) => super::super::__buffa::oneof::cell::Kind::Int64Value(*v),
4109 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
4110 v,
4111 ) => {
4112 super::super::__buffa::oneof::cell::Kind::Uint64Value(*v)
4113 }
4114 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
4115 v,
4116 ) => {
4117 super::super::__buffa::oneof::cell::Kind::Float64Value(*v)
4118 }
4119 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
4120 v,
4121 ) => {
4122 super::super::__buffa::oneof::cell::Kind::BooleanValue(*v)
4123 }
4124 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(
4125 v,
4126 ) => {
4127 super::super::__buffa::oneof::cell::Kind::Utf8Value(
4128 v.to_string(),
4129 )
4130 }
4131 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
4132 v,
4133 ) => {
4134 super::super::__buffa::oneof::cell::Kind::FixedSizeBinaryValue(
4135 ::buffa::view::bytes_from_source(__buffa_src, v),
4136 )
4137 }
4138 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
4139 v,
4140 ) => {
4141 super::super::__buffa::oneof::cell::Kind::Date32Value(*v)
4142 }
4143 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
4144 v,
4145 ) => {
4146 super::super::__buffa::oneof::cell::Kind::Date64Value(*v)
4147 }
4148 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
4149 v,
4150 ) => {
4151 super::super::__buffa::oneof::cell::Kind::TimestampValue(*v)
4152 }
4153 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4154 v,
4155 ) => {
4156 super::super::__buffa::oneof::cell::Kind::Decimal128Value(
4157 ::buffa::view::bytes_from_source(__buffa_src, v),
4158 )
4159 }
4160 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4161 v,
4162 ) => {
4163 super::super::__buffa::oneof::cell::Kind::Decimal256Value(
4164 ::buffa::view::bytes_from_source(__buffa_src, v),
4165 )
4166 }
4167 super::super::__buffa::view::oneof::cell::Kind::ListValue(
4168 v,
4169 ) => {
4170 super::super::__buffa::oneof::cell::Kind::ListValue(
4171 ::buffa::alloc::boxed::Box::new(
4172 v.to_owned_from_source(__buffa_src),
4173 ),
4174 )
4175 }
4176 }),
4177 __buffa_unknown_fields: self
4178 .__buffa_unknown_fields
4179 .to_owned()
4180 .unwrap_or_default()
4181 .into(),
4182 ..::core::default::Default::default()
4183 }
4184 }
4185 }
4186 impl<'a> ::buffa::ViewEncode<'a> for CellView<'a> {
4187 #[allow(clippy::needless_borrow, clippy::let_and_return)]
4188 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
4189 #[allow(unused_imports)]
4190 use ::buffa::Enumeration as _;
4191 let mut size = 0u32;
4192 if let ::core::option::Option::Some(ref v) = self.kind {
4193 match v {
4194 super::super::__buffa::view::oneof::cell::Kind::NullValue(x) => {
4195 let __slot = __cache.reserve();
4196 let inner = x.compute_size(__cache);
4197 __cache.set(__slot, inner);
4198 size
4199 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
4200 + inner;
4201 }
4202 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
4203 v,
4204 ) => {
4205 size += 1u32 + ::buffa::types::int64_encoded_len(*v) as u32;
4206 }
4207 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
4208 v,
4209 ) => {
4210 size += 1u32 + ::buffa::types::uint64_encoded_len(*v) as u32;
4211 }
4212 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
4213 _x,
4214 ) => {
4215 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
4216 }
4217 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
4218 _x,
4219 ) => {
4220 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4221 }
4222 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(x) => {
4223 size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
4224 }
4225 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
4226 x,
4227 ) => {
4228 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
4229 }
4230 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
4231 v,
4232 ) => {
4233 size += 1u32 + ::buffa::types::int32_encoded_len(*v) as u32;
4234 }
4235 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
4236 v,
4237 ) => {
4238 size += 1u32 + ::buffa::types::int64_encoded_len(*v) as u32;
4239 }
4240 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
4241 v,
4242 ) => {
4243 size += 1u32 + ::buffa::types::int64_encoded_len(*v) as u32;
4244 }
4245 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4246 x,
4247 ) => {
4248 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
4249 }
4250 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4251 x,
4252 ) => {
4253 size += 1u32 + ::buffa::types::bytes_encoded_len(x) as u32;
4254 }
4255 super::super::__buffa::view::oneof::cell::Kind::ListValue(x) => {
4256 let __slot = __cache.reserve();
4257 let inner = x.compute_size(__cache);
4258 __cache.set(__slot, inner);
4259 size
4260 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
4261 + inner;
4262 }
4263 }
4264 }
4265 size += self.__buffa_unknown_fields.encoded_len() as u32;
4266 size
4267 }
4268 #[allow(clippy::needless_borrow)]
4269 fn write_to(
4270 &self,
4271 __cache: &mut ::buffa::SizeCache,
4272 buf: &mut impl ::buffa::bytes::BufMut,
4273 ) {
4274 #[allow(unused_imports)]
4275 use ::buffa::Enumeration as _;
4276 if let ::core::option::Option::Some(ref v) = self.kind {
4277 match v {
4278 super::super::__buffa::view::oneof::cell::Kind::NullValue(x) => {
4279 ::buffa::encoding::Tag::new(
4280 1u32,
4281 ::buffa::encoding::WireType::LengthDelimited,
4282 )
4283 .encode(buf);
4284 ::buffa::encoding::encode_varint(
4285 __cache.consume_next() as u64,
4286 buf,
4287 );
4288 x.write_to(__cache, buf);
4289 }
4290 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
4291 x,
4292 ) => {
4293 ::buffa::encoding::Tag::new(
4294 2u32,
4295 ::buffa::encoding::WireType::Varint,
4296 )
4297 .encode(buf);
4298 ::buffa::types::encode_int64(*x, buf);
4299 }
4300 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
4301 x,
4302 ) => {
4303 ::buffa::encoding::Tag::new(
4304 3u32,
4305 ::buffa::encoding::WireType::Varint,
4306 )
4307 .encode(buf);
4308 ::buffa::types::encode_uint64(*x, buf);
4309 }
4310 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
4311 x,
4312 ) => {
4313 ::buffa::encoding::Tag::new(
4314 4u32,
4315 ::buffa::encoding::WireType::Fixed64,
4316 )
4317 .encode(buf);
4318 ::buffa::types::encode_double(*x, buf);
4319 }
4320 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
4321 x,
4322 ) => {
4323 ::buffa::encoding::Tag::new(
4324 5u32,
4325 ::buffa::encoding::WireType::Varint,
4326 )
4327 .encode(buf);
4328 ::buffa::types::encode_bool(*x, buf);
4329 }
4330 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(x) => {
4331 ::buffa::encoding::Tag::new(
4332 6u32,
4333 ::buffa::encoding::WireType::LengthDelimited,
4334 )
4335 .encode(buf);
4336 ::buffa::types::encode_string(x, buf);
4337 }
4338 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
4339 x,
4340 ) => {
4341 ::buffa::encoding::Tag::new(
4342 7u32,
4343 ::buffa::encoding::WireType::LengthDelimited,
4344 )
4345 .encode(buf);
4346 ::buffa::types::encode_bytes(x, buf);
4347 }
4348 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
4349 x,
4350 ) => {
4351 ::buffa::encoding::Tag::new(
4352 8u32,
4353 ::buffa::encoding::WireType::Varint,
4354 )
4355 .encode(buf);
4356 ::buffa::types::encode_int32(*x, buf);
4357 }
4358 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
4359 x,
4360 ) => {
4361 ::buffa::encoding::Tag::new(
4362 9u32,
4363 ::buffa::encoding::WireType::Varint,
4364 )
4365 .encode(buf);
4366 ::buffa::types::encode_int64(*x, buf);
4367 }
4368 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
4369 x,
4370 ) => {
4371 ::buffa::encoding::Tag::new(
4372 10u32,
4373 ::buffa::encoding::WireType::Varint,
4374 )
4375 .encode(buf);
4376 ::buffa::types::encode_int64(*x, buf);
4377 }
4378 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4379 x,
4380 ) => {
4381 ::buffa::encoding::Tag::new(
4382 11u32,
4383 ::buffa::encoding::WireType::LengthDelimited,
4384 )
4385 .encode(buf);
4386 ::buffa::types::encode_bytes(x, buf);
4387 }
4388 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4389 x,
4390 ) => {
4391 ::buffa::encoding::Tag::new(
4392 12u32,
4393 ::buffa::encoding::WireType::LengthDelimited,
4394 )
4395 .encode(buf);
4396 ::buffa::types::encode_bytes(x, buf);
4397 }
4398 super::super::__buffa::view::oneof::cell::Kind::ListValue(x) => {
4399 ::buffa::encoding::Tag::new(
4400 13u32,
4401 ::buffa::encoding::WireType::LengthDelimited,
4402 )
4403 .encode(buf);
4404 ::buffa::encoding::encode_varint(
4405 __cache.consume_next() as u64,
4406 buf,
4407 );
4408 x.write_to(__cache, buf);
4409 }
4410 }
4411 }
4412 self.__buffa_unknown_fields.write_to(buf);
4413 }
4414 }
4415 impl<'__a> ::serde::Serialize for CellView<'__a> {
4427 fn serialize<__S: ::serde::Serializer>(
4428 &self,
4429 __s: __S,
4430 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4431 use ::serde::ser::SerializeMap as _;
4432 let mut __map = __s.serialize_map(::core::option::Option::None)?;
4433 if let ::core::option::Option::Some(ref __ov) = self.kind {
4434 match __ov {
4435 super::super::__buffa::view::oneof::cell::Kind::NullValue(v) => {
4436 __map.serialize_entry("nullValue", v)?;
4437 }
4438 super::super::__buffa::view::oneof::cell::Kind::Int64Value(
4439 v,
4440 ) => {
4441 struct _W(i64);
4442 impl ::serde::Serialize for _W {
4443 fn serialize<__S: ::serde::Serializer>(
4444 &self,
4445 __s: __S,
4446 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4447 ::buffa::json_helpers::int64::serialize(&self.0, __s)
4448 }
4449 }
4450 __map.serialize_entry("int64Value", &_W(*v))?;
4451 }
4452 super::super::__buffa::view::oneof::cell::Kind::Uint64Value(
4453 v,
4454 ) => {
4455 struct _W(u64);
4456 impl ::serde::Serialize for _W {
4457 fn serialize<__S: ::serde::Serializer>(
4458 &self,
4459 __s: __S,
4460 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4461 ::buffa::json_helpers::uint64::serialize(&self.0, __s)
4462 }
4463 }
4464 __map.serialize_entry("uint64Value", &_W(*v))?;
4465 }
4466 super::super::__buffa::view::oneof::cell::Kind::Float64Value(
4467 v,
4468 ) => {
4469 struct _W(f64);
4470 impl ::serde::Serialize for _W {
4471 fn serialize<__S: ::serde::Serializer>(
4472 &self,
4473 __s: __S,
4474 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4475 ::buffa::json_helpers::double::serialize(&self.0, __s)
4476 }
4477 }
4478 __map.serialize_entry("float64Value", &_W(*v))?;
4479 }
4480 super::super::__buffa::view::oneof::cell::Kind::BooleanValue(
4481 v,
4482 ) => {
4483 __map.serialize_entry("booleanValue", v)?;
4484 }
4485 super::super::__buffa::view::oneof::cell::Kind::Utf8Value(v) => {
4486 __map.serialize_entry("utf8Value", v)?;
4487 }
4488 super::super::__buffa::view::oneof::cell::Kind::FixedSizeBinaryValue(
4489 v,
4490 ) => {
4491 struct _W<'__x>(&'__x [u8]);
4492 impl ::serde::Serialize for _W<'_> {
4493 fn serialize<__S: ::serde::Serializer>(
4494 &self,
4495 __s: __S,
4496 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4497 ::buffa::json_helpers::bytes::serialize(self.0, __s)
4498 }
4499 }
4500 __map.serialize_entry("fixedSizeBinaryValue", &_W(v))?;
4501 }
4502 super::super::__buffa::view::oneof::cell::Kind::Date32Value(
4503 v,
4504 ) => {
4505 struct _W(i32);
4506 impl ::serde::Serialize for _W {
4507 fn serialize<__S: ::serde::Serializer>(
4508 &self,
4509 __s: __S,
4510 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4511 ::buffa::json_helpers::int32::serialize(&self.0, __s)
4512 }
4513 }
4514 __map.serialize_entry("date32Value", &_W(*v))?;
4515 }
4516 super::super::__buffa::view::oneof::cell::Kind::Date64Value(
4517 v,
4518 ) => {
4519 struct _W(i64);
4520 impl ::serde::Serialize for _W {
4521 fn serialize<__S: ::serde::Serializer>(
4522 &self,
4523 __s: __S,
4524 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4525 ::buffa::json_helpers::int64::serialize(&self.0, __s)
4526 }
4527 }
4528 __map.serialize_entry("date64Value", &_W(*v))?;
4529 }
4530 super::super::__buffa::view::oneof::cell::Kind::TimestampValue(
4531 v,
4532 ) => {
4533 struct _W(i64);
4534 impl ::serde::Serialize for _W {
4535 fn serialize<__S: ::serde::Serializer>(
4536 &self,
4537 __s: __S,
4538 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4539 ::buffa::json_helpers::int64::serialize(&self.0, __s)
4540 }
4541 }
4542 __map.serialize_entry("timestampValue", &_W(*v))?;
4543 }
4544 super::super::__buffa::view::oneof::cell::Kind::Decimal128Value(
4545 v,
4546 ) => {
4547 struct _W<'__x>(&'__x [u8]);
4548 impl ::serde::Serialize for _W<'_> {
4549 fn serialize<__S: ::serde::Serializer>(
4550 &self,
4551 __s: __S,
4552 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4553 ::buffa::json_helpers::bytes::serialize(self.0, __s)
4554 }
4555 }
4556 __map.serialize_entry("decimal128Value", &_W(v))?;
4557 }
4558 super::super::__buffa::view::oneof::cell::Kind::Decimal256Value(
4559 v,
4560 ) => {
4561 struct _W<'__x>(&'__x [u8]);
4562 impl ::serde::Serialize for _W<'_> {
4563 fn serialize<__S: ::serde::Serializer>(
4564 &self,
4565 __s: __S,
4566 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4567 ::buffa::json_helpers::bytes::serialize(self.0, __s)
4568 }
4569 }
4570 __map.serialize_entry("decimal256Value", &_W(v))?;
4571 }
4572 super::super::__buffa::view::oneof::cell::Kind::ListValue(v) => {
4573 __map.serialize_entry("listValue", v)?;
4574 }
4575 }
4576 }
4577 __map.end()
4578 }
4579 }
4580 impl<'a> ::buffa::MessageName for CellView<'a> {
4581 const PACKAGE: &'static str = "sql.v1";
4582 const NAME: &'static str = "Cell";
4583 const FULL_NAME: &'static str = "sql.v1.Cell";
4584 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Cell";
4585 }
4586 impl<'v> ::buffa::DefaultViewInstance for CellView<'v> {
4587 fn default_view_instance<'a>() -> &'a Self
4588 where
4589 Self: 'a,
4590 {
4591 static VALUE: ::buffa::__private::OnceBox<CellView<'static>> = ::buffa::__private::OnceBox::new();
4592 VALUE
4593 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
4594 <CellView<'static>>::default(),
4595 ))
4596 }
4597 }
4598 impl ::buffa::ViewReborrow for CellView<'static> {
4599 type Reborrowed<'b> = CellView<'b>;
4600 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
4601 this
4602 }
4603 }
4604 #[derive(Clone, Debug, Default)]
4606 pub struct TablesResponseView<'a> {
4607 pub tables: ::buffa::RepeatedView<
4609 'a,
4610 super::super::__buffa::view::TableView<'a>,
4611 >,
4612 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
4613 }
4614 impl<'a> TablesResponseView<'a> {
4615 #[doc(hidden)]
4623 pub fn _decode_depth(
4624 buf: &'a [u8],
4625 depth: u32,
4626 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4627 let mut view = Self::default();
4628 view._merge_into_view(buf, depth)?;
4629 ::core::result::Result::Ok(view)
4630 }
4631 #[doc(hidden)]
4639 pub fn _merge_into_view(
4640 &mut self,
4641 buf: &'a [u8],
4642 depth: u32,
4643 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
4644 let _ = depth;
4645 #[allow(unused_variables)]
4646 let view = self;
4647 let mut cur: &'a [u8] = buf;
4648 while !cur.is_empty() {
4649 let before_tag = cur;
4650 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
4651 match tag.field_number() {
4652 1u32 => {
4653 if tag.wire_type()
4654 != ::buffa::encoding::WireType::LengthDelimited
4655 {
4656 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4657 field_number: 1u32,
4658 expected: 2u8,
4659 actual: tag.wire_type() as u8,
4660 });
4661 }
4662 if depth == 0 {
4663 return Err(::buffa::DecodeError::RecursionLimitExceeded);
4664 }
4665 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
4666 view.tables
4667 .push(
4668 super::super::__buffa::view::TableView::_decode_depth(
4669 sub,
4670 depth - 1,
4671 )?,
4672 );
4673 }
4674 _ => {
4675 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
4676 let span_len = before_tag.len() - cur.len();
4677 view.__buffa_unknown_fields
4678 .push_raw(&before_tag[..span_len]);
4679 }
4680 }
4681 }
4682 ::core::result::Result::Ok(())
4683 }
4684 }
4685 impl<'a> ::buffa::MessageView<'a> for TablesResponseView<'a> {
4686 type Owned = super::super::TablesResponse;
4687 fn decode_view(
4688 buf: &'a [u8],
4689 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4690 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
4691 }
4692 fn decode_view_with_limit(
4693 buf: &'a [u8],
4694 depth: u32,
4695 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4696 Self::_decode_depth(buf, depth)
4697 }
4698 fn to_owned_message(&self) -> super::super::TablesResponse {
4699 self.to_owned_from_source(None)
4700 }
4701 #[allow(clippy::useless_conversion, clippy::needless_update)]
4702 fn to_owned_from_source(
4703 &self,
4704 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
4705 ) -> super::super::TablesResponse {
4706 #[allow(unused_imports)]
4707 use ::buffa::alloc::string::ToString as _;
4708 let _ = __buffa_src;
4709 super::super::TablesResponse {
4710 tables: self
4711 .tables
4712 .iter()
4713 .map(|v| v.to_owned_from_source(__buffa_src))
4714 .collect(),
4715 __buffa_unknown_fields: self
4716 .__buffa_unknown_fields
4717 .to_owned()
4718 .unwrap_or_default()
4719 .into(),
4720 ..::core::default::Default::default()
4721 }
4722 }
4723 }
4724 impl<'a> ::buffa::ViewEncode<'a> for TablesResponseView<'a> {
4725 #[allow(clippy::needless_borrow, clippy::let_and_return)]
4726 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
4727 #[allow(unused_imports)]
4728 use ::buffa::Enumeration as _;
4729 let mut size = 0u32;
4730 for v in &self.tables {
4731 let __slot = __cache.reserve();
4732 let inner_size = v.compute_size(__cache);
4733 __cache.set(__slot, inner_size);
4734 size
4735 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
4736 + inner_size;
4737 }
4738 size += self.__buffa_unknown_fields.encoded_len() as u32;
4739 size
4740 }
4741 #[allow(clippy::needless_borrow)]
4742 fn write_to(
4743 &self,
4744 __cache: &mut ::buffa::SizeCache,
4745 buf: &mut impl ::buffa::bytes::BufMut,
4746 ) {
4747 #[allow(unused_imports)]
4748 use ::buffa::Enumeration as _;
4749 for v in &self.tables {
4750 ::buffa::encoding::Tag::new(
4751 1u32,
4752 ::buffa::encoding::WireType::LengthDelimited,
4753 )
4754 .encode(buf);
4755 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
4756 v.write_to(__cache, buf);
4757 }
4758 self.__buffa_unknown_fields.write_to(buf);
4759 }
4760 }
4761 impl<'__a> ::serde::Serialize for TablesResponseView<'__a> {
4773 fn serialize<__S: ::serde::Serializer>(
4774 &self,
4775 __s: __S,
4776 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4777 use ::serde::ser::SerializeMap as _;
4778 let mut __map = __s.serialize_map(::core::option::Option::None)?;
4779 if !self.tables.is_empty() {
4780 __map.serialize_entry("tables", &*self.tables)?;
4781 }
4782 __map.end()
4783 }
4784 }
4785 impl<'a> ::buffa::MessageName for TablesResponseView<'a> {
4786 const PACKAGE: &'static str = "sql.v1";
4787 const NAME: &'static str = "TablesResponse";
4788 const FULL_NAME: &'static str = "sql.v1.TablesResponse";
4789 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesResponse";
4790 }
4791 impl<'v> ::buffa::DefaultViewInstance for TablesResponseView<'v> {
4792 fn default_view_instance<'a>() -> &'a Self
4793 where
4794 Self: 'a,
4795 {
4796 static VALUE: ::buffa::__private::OnceBox<TablesResponseView<'static>> = ::buffa::__private::OnceBox::new();
4797 VALUE
4798 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
4799 <TablesResponseView<'static>>::default(),
4800 ))
4801 }
4802 }
4803 impl ::buffa::ViewReborrow for TablesResponseView<'static> {
4804 type Reborrowed<'b> = TablesResponseView<'b>;
4805 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
4806 this
4807 }
4808 }
4809 #[derive(Clone, Debug, Default)]
4811 pub struct TablesRequestView<'a> {
4812 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
4813 }
4814 impl<'a> TablesRequestView<'a> {
4815 #[doc(hidden)]
4823 pub fn _decode_depth(
4824 buf: &'a [u8],
4825 depth: u32,
4826 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4827 let mut view = Self::default();
4828 view._merge_into_view(buf, depth)?;
4829 ::core::result::Result::Ok(view)
4830 }
4831 #[doc(hidden)]
4839 pub fn _merge_into_view(
4840 &mut self,
4841 buf: &'a [u8],
4842 depth: u32,
4843 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
4844 let _ = depth;
4845 #[allow(unused_variables)]
4846 let view = self;
4847 let mut cur: &'a [u8] = buf;
4848 while !cur.is_empty() {
4849 let before_tag = cur;
4850 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
4851 match tag.field_number() {
4852 _ => {
4853 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
4854 let span_len = before_tag.len() - cur.len();
4855 view.__buffa_unknown_fields
4856 .push_raw(&before_tag[..span_len]);
4857 }
4858 }
4859 }
4860 ::core::result::Result::Ok(())
4861 }
4862 }
4863 impl<'a> ::buffa::MessageView<'a> for TablesRequestView<'a> {
4864 type Owned = super::super::TablesRequest;
4865 fn decode_view(
4866 buf: &'a [u8],
4867 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4868 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
4869 }
4870 fn decode_view_with_limit(
4871 buf: &'a [u8],
4872 depth: u32,
4873 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4874 Self::_decode_depth(buf, depth)
4875 }
4876 fn to_owned_message(&self) -> super::super::TablesRequest {
4877 self.to_owned_from_source(None)
4878 }
4879 #[allow(clippy::useless_conversion, clippy::needless_update)]
4880 fn to_owned_from_source(
4881 &self,
4882 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
4883 ) -> super::super::TablesRequest {
4884 #[allow(unused_imports)]
4885 use ::buffa::alloc::string::ToString as _;
4886 let _ = __buffa_src;
4887 super::super::TablesRequest {
4888 __buffa_unknown_fields: self
4889 .__buffa_unknown_fields
4890 .to_owned()
4891 .unwrap_or_default()
4892 .into(),
4893 ..::core::default::Default::default()
4894 }
4895 }
4896 }
4897 impl<'a> ::buffa::ViewEncode<'a> for TablesRequestView<'a> {
4898 #[allow(clippy::needless_borrow, clippy::let_and_return)]
4899 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
4900 #[allow(unused_imports)]
4901 use ::buffa::Enumeration as _;
4902 let mut size = 0u32;
4903 size += self.__buffa_unknown_fields.encoded_len() as u32;
4904 size
4905 }
4906 #[allow(clippy::needless_borrow)]
4907 fn write_to(
4908 &self,
4909 _cache: &mut ::buffa::SizeCache,
4910 buf: &mut impl ::buffa::bytes::BufMut,
4911 ) {
4912 #[allow(unused_imports)]
4913 use ::buffa::Enumeration as _;
4914 self.__buffa_unknown_fields.write_to(buf);
4915 }
4916 }
4917 impl<'__a> ::serde::Serialize for TablesRequestView<'__a> {
4929 fn serialize<__S: ::serde::Serializer>(
4930 &self,
4931 __s: __S,
4932 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4933 use ::serde::ser::SerializeMap as _;
4934 let mut __map = __s.serialize_map(::core::option::Option::None)?;
4935 __map.end()
4936 }
4937 }
4938 impl<'a> ::buffa::MessageName for TablesRequestView<'a> {
4939 const PACKAGE: &'static str = "sql.v1";
4940 const NAME: &'static str = "TablesRequest";
4941 const FULL_NAME: &'static str = "sql.v1.TablesRequest";
4942 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.TablesRequest";
4943 }
4944 impl<'v> ::buffa::DefaultViewInstance for TablesRequestView<'v> {
4945 fn default_view_instance<'a>() -> &'a Self
4946 where
4947 Self: 'a,
4948 {
4949 static VALUE: ::buffa::__private::OnceBox<TablesRequestView<'static>> = ::buffa::__private::OnceBox::new();
4950 VALUE
4951 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
4952 <TablesRequestView<'static>>::default(),
4953 ))
4954 }
4955 }
4956 impl ::buffa::ViewReborrow for TablesRequestView<'static> {
4957 type Reborrowed<'b> = TablesRequestView<'b>;
4958 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
4959 this
4960 }
4961 }
4962 #[derive(Clone, Debug, Default)]
4964 pub struct TableView<'a> {
4965 pub name: &'a str,
4969 pub columns: ::buffa::RepeatedView<
4973 'a,
4974 super::super::__buffa::view::ColumnView<'a>,
4975 >,
4976 pub primary_key_columns: ::buffa::RepeatedView<'a, u32>,
4980 pub indexes: ::buffa::RepeatedView<
4984 'a,
4985 super::super::__buffa::view::IndexView<'a>,
4986 >,
4987 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
4988 }
4989 impl<'a> TableView<'a> {
4990 #[doc(hidden)]
4998 pub fn _decode_depth(
4999 buf: &'a [u8],
5000 depth: u32,
5001 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5002 let mut view = Self::default();
5003 view._merge_into_view(buf, depth)?;
5004 ::core::result::Result::Ok(view)
5005 }
5006 #[doc(hidden)]
5014 pub fn _merge_into_view(
5015 &mut self,
5016 buf: &'a [u8],
5017 depth: u32,
5018 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5019 let _ = depth;
5020 #[allow(unused_variables)]
5021 let view = self;
5022 let mut cur: &'a [u8] = buf;
5023 while !cur.is_empty() {
5024 let before_tag = cur;
5025 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
5026 match tag.field_number() {
5027 1u32 => {
5028 if tag.wire_type()
5029 != ::buffa::encoding::WireType::LengthDelimited
5030 {
5031 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5032 field_number: 1u32,
5033 expected: 2u8,
5034 actual: tag.wire_type() as u8,
5035 });
5036 }
5037 view.name = ::buffa::types::borrow_str(&mut cur)?;
5038 }
5039 2u32 => {
5040 if tag.wire_type()
5041 != ::buffa::encoding::WireType::LengthDelimited
5042 {
5043 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5044 field_number: 2u32,
5045 expected: 2u8,
5046 actual: tag.wire_type() as u8,
5047 });
5048 }
5049 if depth == 0 {
5050 return Err(::buffa::DecodeError::RecursionLimitExceeded);
5051 }
5052 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
5053 view.columns
5054 .push(
5055 super::super::__buffa::view::ColumnView::_decode_depth(
5056 sub,
5057 depth - 1,
5058 )?,
5059 );
5060 }
5061 3u32 => {
5062 if tag.wire_type()
5063 == ::buffa::encoding::WireType::LengthDelimited
5064 {
5065 let payload = ::buffa::types::borrow_bytes(&mut cur)?;
5066 let mut pcur: &[u8] = payload;
5067 while !pcur.is_empty() {
5068 view.primary_key_columns
5069 .push(::buffa::types::decode_uint32(&mut pcur)?);
5070 }
5071 } else if tag.wire_type()
5072 == ::buffa::encoding::WireType::Varint
5073 {
5074 view.primary_key_columns
5075 .push(::buffa::types::decode_uint32(&mut cur)?);
5076 } else {
5077 return Err(::buffa::DecodeError::WireTypeMismatch {
5078 field_number: 3u32,
5079 expected: 2u8,
5080 actual: tag.wire_type() as u8,
5081 });
5082 }
5083 }
5084 4u32 => {
5085 if tag.wire_type()
5086 != ::buffa::encoding::WireType::LengthDelimited
5087 {
5088 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5089 field_number: 4u32,
5090 expected: 2u8,
5091 actual: tag.wire_type() as u8,
5092 });
5093 }
5094 if depth == 0 {
5095 return Err(::buffa::DecodeError::RecursionLimitExceeded);
5096 }
5097 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
5098 view.indexes
5099 .push(
5100 super::super::__buffa::view::IndexView::_decode_depth(
5101 sub,
5102 depth - 1,
5103 )?,
5104 );
5105 }
5106 _ => {
5107 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
5108 let span_len = before_tag.len() - cur.len();
5109 view.__buffa_unknown_fields
5110 .push_raw(&before_tag[..span_len]);
5111 }
5112 }
5113 }
5114 ::core::result::Result::Ok(())
5115 }
5116 }
5117 impl<'a> ::buffa::MessageView<'a> for TableView<'a> {
5118 type Owned = super::super::Table;
5119 fn decode_view(
5120 buf: &'a [u8],
5121 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5122 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
5123 }
5124 fn decode_view_with_limit(
5125 buf: &'a [u8],
5126 depth: u32,
5127 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5128 Self::_decode_depth(buf, depth)
5129 }
5130 fn to_owned_message(&self) -> super::super::Table {
5131 self.to_owned_from_source(None)
5132 }
5133 #[allow(clippy::useless_conversion, clippy::needless_update)]
5134 fn to_owned_from_source(
5135 &self,
5136 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
5137 ) -> super::super::Table {
5138 #[allow(unused_imports)]
5139 use ::buffa::alloc::string::ToString as _;
5140 let _ = __buffa_src;
5141 super::super::Table {
5142 name: self.name.to_string(),
5143 columns: self
5144 .columns
5145 .iter()
5146 .map(|v| v.to_owned_from_source(__buffa_src))
5147 .collect(),
5148 primary_key_columns: self.primary_key_columns.to_vec(),
5149 indexes: self
5150 .indexes
5151 .iter()
5152 .map(|v| v.to_owned_from_source(__buffa_src))
5153 .collect(),
5154 __buffa_unknown_fields: self
5155 .__buffa_unknown_fields
5156 .to_owned()
5157 .unwrap_or_default()
5158 .into(),
5159 ..::core::default::Default::default()
5160 }
5161 }
5162 }
5163 impl<'a> ::buffa::ViewEncode<'a> for TableView<'a> {
5164 #[allow(clippy::needless_borrow, clippy::let_and_return)]
5165 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
5166 #[allow(unused_imports)]
5167 use ::buffa::Enumeration as _;
5168 let mut size = 0u32;
5169 if !self.name.is_empty() {
5170 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
5171 }
5172 for v in &self.columns {
5173 let __slot = __cache.reserve();
5174 let inner_size = v.compute_size(__cache);
5175 __cache.set(__slot, inner_size);
5176 size
5177 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5178 + inner_size;
5179 }
5180 if !self.primary_key_columns.is_empty() {
5181 let payload: u32 = self
5182 .primary_key_columns
5183 .iter()
5184 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5185 .sum::<u32>();
5186 size
5187 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
5188 + payload;
5189 }
5190 for v in &self.indexes {
5191 let __slot = __cache.reserve();
5192 let inner_size = v.compute_size(__cache);
5193 __cache.set(__slot, inner_size);
5194 size
5195 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5196 + inner_size;
5197 }
5198 size += self.__buffa_unknown_fields.encoded_len() as u32;
5199 size
5200 }
5201 #[allow(clippy::needless_borrow)]
5202 fn write_to(
5203 &self,
5204 __cache: &mut ::buffa::SizeCache,
5205 buf: &mut impl ::buffa::bytes::BufMut,
5206 ) {
5207 #[allow(unused_imports)]
5208 use ::buffa::Enumeration as _;
5209 if !self.name.is_empty() {
5210 ::buffa::encoding::Tag::new(
5211 1u32,
5212 ::buffa::encoding::WireType::LengthDelimited,
5213 )
5214 .encode(buf);
5215 ::buffa::types::encode_string(&self.name, buf);
5216 }
5217 for v in &self.columns {
5218 ::buffa::encoding::Tag::new(
5219 2u32,
5220 ::buffa::encoding::WireType::LengthDelimited,
5221 )
5222 .encode(buf);
5223 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
5224 v.write_to(__cache, buf);
5225 }
5226 if !self.primary_key_columns.is_empty() {
5227 let payload: u32 = self
5228 .primary_key_columns
5229 .iter()
5230 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5231 .sum::<u32>();
5232 ::buffa::encoding::Tag::new(
5233 3u32,
5234 ::buffa::encoding::WireType::LengthDelimited,
5235 )
5236 .encode(buf);
5237 ::buffa::encoding::encode_varint(payload as u64, buf);
5238 for &v in &self.primary_key_columns {
5239 ::buffa::types::encode_uint32(v, buf);
5240 }
5241 }
5242 for v in &self.indexes {
5243 ::buffa::encoding::Tag::new(
5244 4u32,
5245 ::buffa::encoding::WireType::LengthDelimited,
5246 )
5247 .encode(buf);
5248 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
5249 v.write_to(__cache, buf);
5250 }
5251 self.__buffa_unknown_fields.write_to(buf);
5252 }
5253 }
5254 impl<'__a> ::serde::Serialize for TableView<'__a> {
5266 fn serialize<__S: ::serde::Serializer>(
5267 &self,
5268 __s: __S,
5269 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5270 use ::serde::ser::SerializeMap as _;
5271 let mut __map = __s.serialize_map(::core::option::Option::None)?;
5272 if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
5273 __map.serialize_entry("name", self.name)?;
5274 }
5275 if !self.columns.is_empty() {
5276 __map.serialize_entry("columns", &*self.columns)?;
5277 }
5278 if !self.primary_key_columns.is_empty() {
5279 struct _WSeq<'__x>(&'__x [u32]);
5280 impl ::serde::Serialize for _WSeq<'_> {
5281 fn serialize<__S: ::serde::Serializer>(
5282 &self,
5283 __s: __S,
5284 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5285 ::buffa::json_helpers::proto_seq::serialize(self.0, __s)
5286 }
5287 }
5288 __map
5289 .serialize_entry(
5290 "primaryKeyColumns",
5291 &_WSeq(&self.primary_key_columns),
5292 )?;
5293 }
5294 if !self.indexes.is_empty() {
5295 __map.serialize_entry("indexes", &*self.indexes)?;
5296 }
5297 __map.end()
5298 }
5299 }
5300 impl<'a> ::buffa::MessageName for TableView<'a> {
5301 const PACKAGE: &'static str = "sql.v1";
5302 const NAME: &'static str = "Table";
5303 const FULL_NAME: &'static str = "sql.v1.Table";
5304 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Table";
5305 }
5306 impl<'v> ::buffa::DefaultViewInstance for TableView<'v> {
5307 fn default_view_instance<'a>() -> &'a Self
5308 where
5309 Self: 'a,
5310 {
5311 static VALUE: ::buffa::__private::OnceBox<TableView<'static>> = ::buffa::__private::OnceBox::new();
5312 VALUE
5313 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
5314 <TableView<'static>>::default(),
5315 ))
5316 }
5317 }
5318 impl ::buffa::ViewReborrow for TableView<'static> {
5319 type Reborrowed<'b> = TableView<'b>;
5320 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
5321 this
5322 }
5323 }
5324 #[derive(Clone, Debug, Default)]
5326 pub struct ColumnView<'a> {
5327 pub name: &'a str,
5329 pub data_type: &'a str,
5335 pub nullable: bool,
5337 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
5338 }
5339 impl<'a> ColumnView<'a> {
5340 #[doc(hidden)]
5348 pub fn _decode_depth(
5349 buf: &'a [u8],
5350 depth: u32,
5351 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5352 let mut view = Self::default();
5353 view._merge_into_view(buf, depth)?;
5354 ::core::result::Result::Ok(view)
5355 }
5356 #[doc(hidden)]
5364 pub fn _merge_into_view(
5365 &mut self,
5366 buf: &'a [u8],
5367 depth: u32,
5368 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5369 let _ = depth;
5370 #[allow(unused_variables)]
5371 let view = self;
5372 let mut cur: &'a [u8] = buf;
5373 while !cur.is_empty() {
5374 let before_tag = cur;
5375 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
5376 match tag.field_number() {
5377 1u32 => {
5378 if tag.wire_type()
5379 != ::buffa::encoding::WireType::LengthDelimited
5380 {
5381 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5382 field_number: 1u32,
5383 expected: 2u8,
5384 actual: tag.wire_type() as u8,
5385 });
5386 }
5387 view.name = ::buffa::types::borrow_str(&mut cur)?;
5388 }
5389 2u32 => {
5390 if tag.wire_type()
5391 != ::buffa::encoding::WireType::LengthDelimited
5392 {
5393 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5394 field_number: 2u32,
5395 expected: 2u8,
5396 actual: tag.wire_type() as u8,
5397 });
5398 }
5399 view.data_type = ::buffa::types::borrow_str(&mut cur)?;
5400 }
5401 3u32 => {
5402 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5403 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5404 field_number: 3u32,
5405 expected: 0u8,
5406 actual: tag.wire_type() as u8,
5407 });
5408 }
5409 view.nullable = ::buffa::types::decode_bool(&mut cur)?;
5410 }
5411 _ => {
5412 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
5413 let span_len = before_tag.len() - cur.len();
5414 view.__buffa_unknown_fields
5415 .push_raw(&before_tag[..span_len]);
5416 }
5417 }
5418 }
5419 ::core::result::Result::Ok(())
5420 }
5421 }
5422 impl<'a> ::buffa::MessageView<'a> for ColumnView<'a> {
5423 type Owned = super::super::Column;
5424 fn decode_view(
5425 buf: &'a [u8],
5426 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5427 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
5428 }
5429 fn decode_view_with_limit(
5430 buf: &'a [u8],
5431 depth: u32,
5432 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5433 Self::_decode_depth(buf, depth)
5434 }
5435 fn to_owned_message(&self) -> super::super::Column {
5436 self.to_owned_from_source(None)
5437 }
5438 #[allow(clippy::useless_conversion, clippy::needless_update)]
5439 fn to_owned_from_source(
5440 &self,
5441 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
5442 ) -> super::super::Column {
5443 #[allow(unused_imports)]
5444 use ::buffa::alloc::string::ToString as _;
5445 let _ = __buffa_src;
5446 super::super::Column {
5447 name: self.name.to_string(),
5448 data_type: self.data_type.to_string(),
5449 nullable: self.nullable,
5450 __buffa_unknown_fields: self
5451 .__buffa_unknown_fields
5452 .to_owned()
5453 .unwrap_or_default()
5454 .into(),
5455 ..::core::default::Default::default()
5456 }
5457 }
5458 }
5459 impl<'a> ::buffa::ViewEncode<'a> for ColumnView<'a> {
5460 #[allow(clippy::needless_borrow, clippy::let_and_return)]
5461 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
5462 #[allow(unused_imports)]
5463 use ::buffa::Enumeration as _;
5464 let mut size = 0u32;
5465 if !self.name.is_empty() {
5466 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
5467 }
5468 if !self.data_type.is_empty() {
5469 size
5470 += 1u32
5471 + ::buffa::types::string_encoded_len(&self.data_type) as u32;
5472 }
5473 if self.nullable {
5474 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
5475 }
5476 size += self.__buffa_unknown_fields.encoded_len() as u32;
5477 size
5478 }
5479 #[allow(clippy::needless_borrow)]
5480 fn write_to(
5481 &self,
5482 _cache: &mut ::buffa::SizeCache,
5483 buf: &mut impl ::buffa::bytes::BufMut,
5484 ) {
5485 #[allow(unused_imports)]
5486 use ::buffa::Enumeration as _;
5487 if !self.name.is_empty() {
5488 ::buffa::encoding::Tag::new(
5489 1u32,
5490 ::buffa::encoding::WireType::LengthDelimited,
5491 )
5492 .encode(buf);
5493 ::buffa::types::encode_string(&self.name, buf);
5494 }
5495 if !self.data_type.is_empty() {
5496 ::buffa::encoding::Tag::new(
5497 2u32,
5498 ::buffa::encoding::WireType::LengthDelimited,
5499 )
5500 .encode(buf);
5501 ::buffa::types::encode_string(&self.data_type, buf);
5502 }
5503 if self.nullable {
5504 ::buffa::encoding::Tag::new(
5505 3u32,
5506 ::buffa::encoding::WireType::Varint,
5507 )
5508 .encode(buf);
5509 ::buffa::types::encode_bool(self.nullable, buf);
5510 }
5511 self.__buffa_unknown_fields.write_to(buf);
5512 }
5513 }
5514 impl<'__a> ::serde::Serialize for ColumnView<'__a> {
5526 fn serialize<__S: ::serde::Serializer>(
5527 &self,
5528 __s: __S,
5529 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5530 use ::serde::ser::SerializeMap as _;
5531 let mut __map = __s.serialize_map(::core::option::Option::None)?;
5532 if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
5533 __map.serialize_entry("name", self.name)?;
5534 }
5535 if !::buffa::json_helpers::skip_if::is_empty_str(self.data_type) {
5536 __map.serialize_entry("dataType", self.data_type)?;
5537 }
5538 if self.nullable {
5539 __map.serialize_entry("nullable", &self.nullable)?;
5540 }
5541 __map.end()
5542 }
5543 }
5544 impl<'a> ::buffa::MessageName for ColumnView<'a> {
5545 const PACKAGE: &'static str = "sql.v1";
5546 const NAME: &'static str = "Column";
5547 const FULL_NAME: &'static str = "sql.v1.Column";
5548 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Column";
5549 }
5550 impl<'v> ::buffa::DefaultViewInstance for ColumnView<'v> {
5551 fn default_view_instance<'a>() -> &'a Self
5552 where
5553 Self: 'a,
5554 {
5555 static VALUE: ::buffa::__private::OnceBox<ColumnView<'static>> = ::buffa::__private::OnceBox::new();
5556 VALUE
5557 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
5558 <ColumnView<'static>>::default(),
5559 ))
5560 }
5561 }
5562 impl ::buffa::ViewReborrow for ColumnView<'static> {
5563 type Reborrowed<'b> = ColumnView<'b>;
5564 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
5565 this
5566 }
5567 }
5568 #[derive(Clone, Debug, Default)]
5570 pub struct IndexView<'a> {
5571 pub name: &'a str,
5573 pub layout: ::buffa::EnumValue<super::super::IndexLayout>,
5575 pub key_columns: ::buffa::RepeatedView<'a, u32>,
5579 pub cover_columns: ::buffa::RepeatedView<'a, u32>,
5584 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
5585 }
5586 impl<'a> IndexView<'a> {
5587 #[doc(hidden)]
5595 pub fn _decode_depth(
5596 buf: &'a [u8],
5597 depth: u32,
5598 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5599 let mut view = Self::default();
5600 view._merge_into_view(buf, depth)?;
5601 ::core::result::Result::Ok(view)
5602 }
5603 #[doc(hidden)]
5611 pub fn _merge_into_view(
5612 &mut self,
5613 buf: &'a [u8],
5614 depth: u32,
5615 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5616 let _ = depth;
5617 #[allow(unused_variables)]
5618 let view = self;
5619 let mut cur: &'a [u8] = buf;
5620 while !cur.is_empty() {
5621 let before_tag = cur;
5622 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
5623 match tag.field_number() {
5624 1u32 => {
5625 if tag.wire_type()
5626 != ::buffa::encoding::WireType::LengthDelimited
5627 {
5628 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5629 field_number: 1u32,
5630 expected: 2u8,
5631 actual: tag.wire_type() as u8,
5632 });
5633 }
5634 view.name = ::buffa::types::borrow_str(&mut cur)?;
5635 }
5636 2u32 => {
5637 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5638 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5639 field_number: 2u32,
5640 expected: 0u8,
5641 actual: tag.wire_type() as u8,
5642 });
5643 }
5644 view.layout = ::buffa::EnumValue::from(
5645 ::buffa::types::decode_int32(&mut cur)?,
5646 );
5647 }
5648 3u32 => {
5649 if tag.wire_type()
5650 == ::buffa::encoding::WireType::LengthDelimited
5651 {
5652 let payload = ::buffa::types::borrow_bytes(&mut cur)?;
5653 let mut pcur: &[u8] = payload;
5654 while !pcur.is_empty() {
5655 view.key_columns
5656 .push(::buffa::types::decode_uint32(&mut pcur)?);
5657 }
5658 } else if tag.wire_type()
5659 == ::buffa::encoding::WireType::Varint
5660 {
5661 view.key_columns
5662 .push(::buffa::types::decode_uint32(&mut cur)?);
5663 } else {
5664 return Err(::buffa::DecodeError::WireTypeMismatch {
5665 field_number: 3u32,
5666 expected: 2u8,
5667 actual: tag.wire_type() as u8,
5668 });
5669 }
5670 }
5671 4u32 => {
5672 if tag.wire_type()
5673 == ::buffa::encoding::WireType::LengthDelimited
5674 {
5675 let payload = ::buffa::types::borrow_bytes(&mut cur)?;
5676 let mut pcur: &[u8] = payload;
5677 while !pcur.is_empty() {
5678 view.cover_columns
5679 .push(::buffa::types::decode_uint32(&mut pcur)?);
5680 }
5681 } else if tag.wire_type()
5682 == ::buffa::encoding::WireType::Varint
5683 {
5684 view.cover_columns
5685 .push(::buffa::types::decode_uint32(&mut cur)?);
5686 } else {
5687 return Err(::buffa::DecodeError::WireTypeMismatch {
5688 field_number: 4u32,
5689 expected: 2u8,
5690 actual: tag.wire_type() as u8,
5691 });
5692 }
5693 }
5694 _ => {
5695 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
5696 let span_len = before_tag.len() - cur.len();
5697 view.__buffa_unknown_fields
5698 .push_raw(&before_tag[..span_len]);
5699 }
5700 }
5701 }
5702 ::core::result::Result::Ok(())
5703 }
5704 }
5705 impl<'a> ::buffa::MessageView<'a> for IndexView<'a> {
5706 type Owned = super::super::Index;
5707 fn decode_view(
5708 buf: &'a [u8],
5709 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5710 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
5711 }
5712 fn decode_view_with_limit(
5713 buf: &'a [u8],
5714 depth: u32,
5715 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5716 Self::_decode_depth(buf, depth)
5717 }
5718 fn to_owned_message(&self) -> super::super::Index {
5719 self.to_owned_from_source(None)
5720 }
5721 #[allow(clippy::useless_conversion, clippy::needless_update)]
5722 fn to_owned_from_source(
5723 &self,
5724 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
5725 ) -> super::super::Index {
5726 #[allow(unused_imports)]
5727 use ::buffa::alloc::string::ToString as _;
5728 let _ = __buffa_src;
5729 super::super::Index {
5730 name: self.name.to_string(),
5731 layout: self.layout,
5732 key_columns: self.key_columns.to_vec(),
5733 cover_columns: self.cover_columns.to_vec(),
5734 __buffa_unknown_fields: self
5735 .__buffa_unknown_fields
5736 .to_owned()
5737 .unwrap_or_default()
5738 .into(),
5739 ..::core::default::Default::default()
5740 }
5741 }
5742 }
5743 impl<'a> ::buffa::ViewEncode<'a> for IndexView<'a> {
5744 #[allow(clippy::needless_borrow, clippy::let_and_return)]
5745 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
5746 #[allow(unused_imports)]
5747 use ::buffa::Enumeration as _;
5748 let mut size = 0u32;
5749 if !self.name.is_empty() {
5750 size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
5751 }
5752 {
5753 let val = self.layout.to_i32();
5754 if val != 0 {
5755 size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
5756 }
5757 }
5758 if !self.key_columns.is_empty() {
5759 let payload: u32 = self
5760 .key_columns
5761 .iter()
5762 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5763 .sum::<u32>();
5764 size
5765 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
5766 + payload;
5767 }
5768 if !self.cover_columns.is_empty() {
5769 let payload: u32 = self
5770 .cover_columns
5771 .iter()
5772 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5773 .sum::<u32>();
5774 size
5775 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
5776 + payload;
5777 }
5778 size += self.__buffa_unknown_fields.encoded_len() as u32;
5779 size
5780 }
5781 #[allow(clippy::needless_borrow)]
5782 fn write_to(
5783 &self,
5784 _cache: &mut ::buffa::SizeCache,
5785 buf: &mut impl ::buffa::bytes::BufMut,
5786 ) {
5787 #[allow(unused_imports)]
5788 use ::buffa::Enumeration as _;
5789 if !self.name.is_empty() {
5790 ::buffa::encoding::Tag::new(
5791 1u32,
5792 ::buffa::encoding::WireType::LengthDelimited,
5793 )
5794 .encode(buf);
5795 ::buffa::types::encode_string(&self.name, buf);
5796 }
5797 {
5798 let val = self.layout.to_i32();
5799 if val != 0 {
5800 ::buffa::encoding::Tag::new(
5801 2u32,
5802 ::buffa::encoding::WireType::Varint,
5803 )
5804 .encode(buf);
5805 ::buffa::types::encode_int32(val, buf);
5806 }
5807 }
5808 if !self.key_columns.is_empty() {
5809 let payload: u32 = self
5810 .key_columns
5811 .iter()
5812 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5813 .sum::<u32>();
5814 ::buffa::encoding::Tag::new(
5815 3u32,
5816 ::buffa::encoding::WireType::LengthDelimited,
5817 )
5818 .encode(buf);
5819 ::buffa::encoding::encode_varint(payload as u64, buf);
5820 for &v in &self.key_columns {
5821 ::buffa::types::encode_uint32(v, buf);
5822 }
5823 }
5824 if !self.cover_columns.is_empty() {
5825 let payload: u32 = self
5826 .cover_columns
5827 .iter()
5828 .map(|&v| ::buffa::types::uint32_encoded_len(v) as u32)
5829 .sum::<u32>();
5830 ::buffa::encoding::Tag::new(
5831 4u32,
5832 ::buffa::encoding::WireType::LengthDelimited,
5833 )
5834 .encode(buf);
5835 ::buffa::encoding::encode_varint(payload as u64, buf);
5836 for &v in &self.cover_columns {
5837 ::buffa::types::encode_uint32(v, buf);
5838 }
5839 }
5840 self.__buffa_unknown_fields.write_to(buf);
5841 }
5842 }
5843 impl<'__a> ::serde::Serialize for IndexView<'__a> {
5855 fn serialize<__S: ::serde::Serializer>(
5856 &self,
5857 __s: __S,
5858 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5859 use ::serde::ser::SerializeMap as _;
5860 let mut __map = __s.serialize_map(::core::option::Option::None)?;
5861 if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
5862 __map.serialize_entry("name", self.name)?;
5863 }
5864 if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.layout) {
5865 __map.serialize_entry("layout", &self.layout)?;
5866 }
5867 if !self.key_columns.is_empty() {
5868 struct _WSeq<'__x>(&'__x [u32]);
5869 impl ::serde::Serialize for _WSeq<'_> {
5870 fn serialize<__S: ::serde::Serializer>(
5871 &self,
5872 __s: __S,
5873 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5874 ::buffa::json_helpers::proto_seq::serialize(self.0, __s)
5875 }
5876 }
5877 __map.serialize_entry("keyColumns", &_WSeq(&self.key_columns))?;
5878 }
5879 if !self.cover_columns.is_empty() {
5880 struct _WSeq<'__x>(&'__x [u32]);
5881 impl ::serde::Serialize for _WSeq<'_> {
5882 fn serialize<__S: ::serde::Serializer>(
5883 &self,
5884 __s: __S,
5885 ) -> ::core::result::Result<__S::Ok, __S::Error> {
5886 ::buffa::json_helpers::proto_seq::serialize(self.0, __s)
5887 }
5888 }
5889 __map.serialize_entry("coverColumns", &_WSeq(&self.cover_columns))?;
5890 }
5891 __map.end()
5892 }
5893 }
5894 impl<'a> ::buffa::MessageName for IndexView<'a> {
5895 const PACKAGE: &'static str = "sql.v1";
5896 const NAME: &'static str = "Index";
5897 const FULL_NAME: &'static str = "sql.v1.Index";
5898 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.Index";
5899 }
5900 impl<'v> ::buffa::DefaultViewInstance for IndexView<'v> {
5901 fn default_view_instance<'a>() -> &'a Self
5902 where
5903 Self: 'a,
5904 {
5905 static VALUE: ::buffa::__private::OnceBox<IndexView<'static>> = ::buffa::__private::OnceBox::new();
5906 VALUE
5907 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
5908 <IndexView<'static>>::default(),
5909 ))
5910 }
5911 }
5912 impl ::buffa::ViewReborrow for IndexView<'static> {
5913 type Reborrowed<'b> = IndexView<'b>;
5914 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
5915 this
5916 }
5917 }
5918 #[derive(Clone, Debug, Default)]
5920 pub struct QueryRequestView<'a> {
5921 pub sql: &'a str,
5923 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
5924 }
5925 impl<'a> QueryRequestView<'a> {
5926 #[doc(hidden)]
5934 pub fn _decode_depth(
5935 buf: &'a [u8],
5936 depth: u32,
5937 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5938 let mut view = Self::default();
5939 view._merge_into_view(buf, depth)?;
5940 ::core::result::Result::Ok(view)
5941 }
5942 #[doc(hidden)]
5950 pub fn _merge_into_view(
5951 &mut self,
5952 buf: &'a [u8],
5953 depth: u32,
5954 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5955 let _ = depth;
5956 #[allow(unused_variables)]
5957 let view = self;
5958 let mut cur: &'a [u8] = buf;
5959 while !cur.is_empty() {
5960 let before_tag = cur;
5961 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
5962 match tag.field_number() {
5963 1u32 => {
5964 if tag.wire_type()
5965 != ::buffa::encoding::WireType::LengthDelimited
5966 {
5967 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5968 field_number: 1u32,
5969 expected: 2u8,
5970 actual: tag.wire_type() as u8,
5971 });
5972 }
5973 view.sql = ::buffa::types::borrow_str(&mut cur)?;
5974 }
5975 _ => {
5976 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
5977 let span_len = before_tag.len() - cur.len();
5978 view.__buffa_unknown_fields
5979 .push_raw(&before_tag[..span_len]);
5980 }
5981 }
5982 }
5983 ::core::result::Result::Ok(())
5984 }
5985 }
5986 impl<'a> ::buffa::MessageView<'a> for QueryRequestView<'a> {
5987 type Owned = super::super::QueryRequest;
5988 fn decode_view(
5989 buf: &'a [u8],
5990 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5991 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
5992 }
5993 fn decode_view_with_limit(
5994 buf: &'a [u8],
5995 depth: u32,
5996 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
5997 Self::_decode_depth(buf, depth)
5998 }
5999 fn to_owned_message(&self) -> super::super::QueryRequest {
6000 self.to_owned_from_source(None)
6001 }
6002 #[allow(clippy::useless_conversion, clippy::needless_update)]
6003 fn to_owned_from_source(
6004 &self,
6005 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
6006 ) -> super::super::QueryRequest {
6007 #[allow(unused_imports)]
6008 use ::buffa::alloc::string::ToString as _;
6009 let _ = __buffa_src;
6010 super::super::QueryRequest {
6011 sql: self.sql.to_string(),
6012 __buffa_unknown_fields: self
6013 .__buffa_unknown_fields
6014 .to_owned()
6015 .unwrap_or_default()
6016 .into(),
6017 ..::core::default::Default::default()
6018 }
6019 }
6020 }
6021 impl<'a> ::buffa::ViewEncode<'a> for QueryRequestView<'a> {
6022 #[allow(clippy::needless_borrow, clippy::let_and_return)]
6023 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
6024 #[allow(unused_imports)]
6025 use ::buffa::Enumeration as _;
6026 let mut size = 0u32;
6027 if !self.sql.is_empty() {
6028 size += 1u32 + ::buffa::types::string_encoded_len(&self.sql) as u32;
6029 }
6030 size += self.__buffa_unknown_fields.encoded_len() as u32;
6031 size
6032 }
6033 #[allow(clippy::needless_borrow)]
6034 fn write_to(
6035 &self,
6036 _cache: &mut ::buffa::SizeCache,
6037 buf: &mut impl ::buffa::bytes::BufMut,
6038 ) {
6039 #[allow(unused_imports)]
6040 use ::buffa::Enumeration as _;
6041 if !self.sql.is_empty() {
6042 ::buffa::encoding::Tag::new(
6043 1u32,
6044 ::buffa::encoding::WireType::LengthDelimited,
6045 )
6046 .encode(buf);
6047 ::buffa::types::encode_string(&self.sql, buf);
6048 }
6049 self.__buffa_unknown_fields.write_to(buf);
6050 }
6051 }
6052 impl<'__a> ::serde::Serialize for QueryRequestView<'__a> {
6064 fn serialize<__S: ::serde::Serializer>(
6065 &self,
6066 __s: __S,
6067 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6068 use ::serde::ser::SerializeMap as _;
6069 let mut __map = __s.serialize_map(::core::option::Option::None)?;
6070 if !::buffa::json_helpers::skip_if::is_empty_str(self.sql) {
6071 __map.serialize_entry("sql", self.sql)?;
6072 }
6073 __map.end()
6074 }
6075 }
6076 impl<'a> ::buffa::MessageName for QueryRequestView<'a> {
6077 const PACKAGE: &'static str = "sql.v1";
6078 const NAME: &'static str = "QueryRequest";
6079 const FULL_NAME: &'static str = "sql.v1.QueryRequest";
6080 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryRequest";
6081 }
6082 impl<'v> ::buffa::DefaultViewInstance for QueryRequestView<'v> {
6083 fn default_view_instance<'a>() -> &'a Self
6084 where
6085 Self: 'a,
6086 {
6087 static VALUE: ::buffa::__private::OnceBox<QueryRequestView<'static>> = ::buffa::__private::OnceBox::new();
6088 VALUE
6089 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6090 <QueryRequestView<'static>>::default(),
6091 ))
6092 }
6093 }
6094 impl ::buffa::ViewReborrow for QueryRequestView<'static> {
6095 type Reborrowed<'b> = QueryRequestView<'b>;
6096 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
6097 this
6098 }
6099 }
6100 #[derive(Clone, Debug, Default)]
6102 pub struct QueryResponseView<'a> {
6103 pub column: ::buffa::RepeatedView<'a, &'a str>,
6105 pub rows: ::buffa::RepeatedView<
6107 'a,
6108 super::super::__buffa::view::RowView<'a>,
6109 >,
6110 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
6111 }
6112 impl<'a> QueryResponseView<'a> {
6113 #[doc(hidden)]
6121 pub fn _decode_depth(
6122 buf: &'a [u8],
6123 depth: u32,
6124 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6125 let mut view = Self::default();
6126 view._merge_into_view(buf, depth)?;
6127 ::core::result::Result::Ok(view)
6128 }
6129 #[doc(hidden)]
6137 pub fn _merge_into_view(
6138 &mut self,
6139 buf: &'a [u8],
6140 depth: u32,
6141 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6142 let _ = depth;
6143 #[allow(unused_variables)]
6144 let view = self;
6145 let mut cur: &'a [u8] = buf;
6146 while !cur.is_empty() {
6147 let before_tag = cur;
6148 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
6149 match tag.field_number() {
6150 1u32 => {
6151 if tag.wire_type()
6152 != ::buffa::encoding::WireType::LengthDelimited
6153 {
6154 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6155 field_number: 1u32,
6156 expected: 2u8,
6157 actual: tag.wire_type() as u8,
6158 });
6159 }
6160 view.column.push(::buffa::types::borrow_str(&mut cur)?);
6161 }
6162 2u32 => {
6163 if tag.wire_type()
6164 != ::buffa::encoding::WireType::LengthDelimited
6165 {
6166 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6167 field_number: 2u32,
6168 expected: 2u8,
6169 actual: tag.wire_type() as u8,
6170 });
6171 }
6172 if depth == 0 {
6173 return Err(::buffa::DecodeError::RecursionLimitExceeded);
6174 }
6175 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
6176 view.rows
6177 .push(
6178 super::super::__buffa::view::RowView::_decode_depth(
6179 sub,
6180 depth - 1,
6181 )?,
6182 );
6183 }
6184 _ => {
6185 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
6186 let span_len = before_tag.len() - cur.len();
6187 view.__buffa_unknown_fields
6188 .push_raw(&before_tag[..span_len]);
6189 }
6190 }
6191 }
6192 ::core::result::Result::Ok(())
6193 }
6194 }
6195 impl<'a> ::buffa::MessageView<'a> for QueryResponseView<'a> {
6196 type Owned = super::super::QueryResponse;
6197 fn decode_view(
6198 buf: &'a [u8],
6199 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6200 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
6201 }
6202 fn decode_view_with_limit(
6203 buf: &'a [u8],
6204 depth: u32,
6205 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6206 Self::_decode_depth(buf, depth)
6207 }
6208 fn to_owned_message(&self) -> super::super::QueryResponse {
6209 self.to_owned_from_source(None)
6210 }
6211 #[allow(clippy::useless_conversion, clippy::needless_update)]
6212 fn to_owned_from_source(
6213 &self,
6214 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
6215 ) -> super::super::QueryResponse {
6216 #[allow(unused_imports)]
6217 use ::buffa::alloc::string::ToString as _;
6218 let _ = __buffa_src;
6219 super::super::QueryResponse {
6220 column: self.column.iter().map(|s| s.to_string()).collect(),
6221 rows: self
6222 .rows
6223 .iter()
6224 .map(|v| v.to_owned_from_source(__buffa_src))
6225 .collect(),
6226 __buffa_unknown_fields: self
6227 .__buffa_unknown_fields
6228 .to_owned()
6229 .unwrap_or_default()
6230 .into(),
6231 ..::core::default::Default::default()
6232 }
6233 }
6234 }
6235 impl<'a> ::buffa::ViewEncode<'a> for QueryResponseView<'a> {
6236 #[allow(clippy::needless_borrow, clippy::let_and_return)]
6237 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
6238 #[allow(unused_imports)]
6239 use ::buffa::Enumeration as _;
6240 let mut size = 0u32;
6241 for v in &self.column {
6242 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
6243 }
6244 for v in &self.rows {
6245 let __slot = __cache.reserve();
6246 let inner_size = v.compute_size(__cache);
6247 __cache.set(__slot, inner_size);
6248 size
6249 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
6250 + inner_size;
6251 }
6252 size += self.__buffa_unknown_fields.encoded_len() as u32;
6253 size
6254 }
6255 #[allow(clippy::needless_borrow)]
6256 fn write_to(
6257 &self,
6258 __cache: &mut ::buffa::SizeCache,
6259 buf: &mut impl ::buffa::bytes::BufMut,
6260 ) {
6261 #[allow(unused_imports)]
6262 use ::buffa::Enumeration as _;
6263 for v in &self.column {
6264 ::buffa::encoding::Tag::new(
6265 1u32,
6266 ::buffa::encoding::WireType::LengthDelimited,
6267 )
6268 .encode(buf);
6269 ::buffa::types::encode_string(v, buf);
6270 }
6271 for v in &self.rows {
6272 ::buffa::encoding::Tag::new(
6273 2u32,
6274 ::buffa::encoding::WireType::LengthDelimited,
6275 )
6276 .encode(buf);
6277 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
6278 v.write_to(__cache, buf);
6279 }
6280 self.__buffa_unknown_fields.write_to(buf);
6281 }
6282 }
6283 impl<'__a> ::serde::Serialize for QueryResponseView<'__a> {
6295 fn serialize<__S: ::serde::Serializer>(
6296 &self,
6297 __s: __S,
6298 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6299 use ::serde::ser::SerializeMap as _;
6300 let mut __map = __s.serialize_map(::core::option::Option::None)?;
6301 if !self.column.is_empty() {
6302 __map.serialize_entry("column", &*self.column)?;
6303 }
6304 if !self.rows.is_empty() {
6305 __map.serialize_entry("rows", &*self.rows)?;
6306 }
6307 __map.end()
6308 }
6309 }
6310 impl<'a> ::buffa::MessageName for QueryResponseView<'a> {
6311 const PACKAGE: &'static str = "sql.v1";
6312 const NAME: &'static str = "QueryResponse";
6313 const FULL_NAME: &'static str = "sql.v1.QueryResponse";
6314 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.QueryResponse";
6315 }
6316 impl<'v> ::buffa::DefaultViewInstance for QueryResponseView<'v> {
6317 fn default_view_instance<'a>() -> &'a Self
6318 where
6319 Self: 'a,
6320 {
6321 static VALUE: ::buffa::__private::OnceBox<QueryResponseView<'static>> = ::buffa::__private::OnceBox::new();
6322 VALUE
6323 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6324 <QueryResponseView<'static>>::default(),
6325 ))
6326 }
6327 }
6328 impl ::buffa::ViewReborrow for QueryResponseView<'static> {
6329 type Reborrowed<'b> = QueryResponseView<'b>;
6330 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
6331 this
6332 }
6333 }
6334 #[derive(Clone, Debug, Default)]
6336 pub struct SubscribeRequestView<'a> {
6337 pub table: &'a str,
6341 pub where_sql: &'a str,
6347 pub since_sequence_number: ::core::option::Option<u64>,
6352 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
6353 }
6354 impl<'a> SubscribeRequestView<'a> {
6355 #[doc(hidden)]
6363 pub fn _decode_depth(
6364 buf: &'a [u8],
6365 depth: u32,
6366 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6367 let mut view = Self::default();
6368 view._merge_into_view(buf, depth)?;
6369 ::core::result::Result::Ok(view)
6370 }
6371 #[doc(hidden)]
6379 pub fn _merge_into_view(
6380 &mut self,
6381 buf: &'a [u8],
6382 depth: u32,
6383 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6384 let _ = depth;
6385 #[allow(unused_variables)]
6386 let view = self;
6387 let mut cur: &'a [u8] = buf;
6388 while !cur.is_empty() {
6389 let before_tag = cur;
6390 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
6391 match tag.field_number() {
6392 1u32 => {
6393 if tag.wire_type()
6394 != ::buffa::encoding::WireType::LengthDelimited
6395 {
6396 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6397 field_number: 1u32,
6398 expected: 2u8,
6399 actual: tag.wire_type() as u8,
6400 });
6401 }
6402 view.table = ::buffa::types::borrow_str(&mut cur)?;
6403 }
6404 2u32 => {
6405 if tag.wire_type()
6406 != ::buffa::encoding::WireType::LengthDelimited
6407 {
6408 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6409 field_number: 2u32,
6410 expected: 2u8,
6411 actual: tag.wire_type() as u8,
6412 });
6413 }
6414 view.where_sql = ::buffa::types::borrow_str(&mut cur)?;
6415 }
6416 3u32 => {
6417 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6418 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6419 field_number: 3u32,
6420 expected: 0u8,
6421 actual: tag.wire_type() as u8,
6422 });
6423 }
6424 view.since_sequence_number = Some(
6425 ::buffa::types::decode_uint64(&mut cur)?,
6426 );
6427 }
6428 _ => {
6429 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
6430 let span_len = before_tag.len() - cur.len();
6431 view.__buffa_unknown_fields
6432 .push_raw(&before_tag[..span_len]);
6433 }
6434 }
6435 }
6436 ::core::result::Result::Ok(())
6437 }
6438 }
6439 impl<'a> ::buffa::MessageView<'a> for SubscribeRequestView<'a> {
6440 type Owned = super::super::SubscribeRequest;
6441 fn decode_view(
6442 buf: &'a [u8],
6443 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6444 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
6445 }
6446 fn decode_view_with_limit(
6447 buf: &'a [u8],
6448 depth: u32,
6449 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6450 Self::_decode_depth(buf, depth)
6451 }
6452 fn to_owned_message(&self) -> super::super::SubscribeRequest {
6453 self.to_owned_from_source(None)
6454 }
6455 #[allow(clippy::useless_conversion, clippy::needless_update)]
6456 fn to_owned_from_source(
6457 &self,
6458 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
6459 ) -> super::super::SubscribeRequest {
6460 #[allow(unused_imports)]
6461 use ::buffa::alloc::string::ToString as _;
6462 let _ = __buffa_src;
6463 super::super::SubscribeRequest {
6464 table: self.table.to_string(),
6465 where_sql: self.where_sql.to_string(),
6466 since_sequence_number: self.since_sequence_number,
6467 __buffa_unknown_fields: self
6468 .__buffa_unknown_fields
6469 .to_owned()
6470 .unwrap_or_default()
6471 .into(),
6472 ..::core::default::Default::default()
6473 }
6474 }
6475 }
6476 impl<'a> ::buffa::ViewEncode<'a> for SubscribeRequestView<'a> {
6477 #[allow(clippy::needless_borrow, clippy::let_and_return)]
6478 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
6479 #[allow(unused_imports)]
6480 use ::buffa::Enumeration as _;
6481 let mut size = 0u32;
6482 if !self.table.is_empty() {
6483 size
6484 += 1u32 + ::buffa::types::string_encoded_len(&self.table) as u32;
6485 }
6486 if !self.where_sql.is_empty() {
6487 size
6488 += 1u32
6489 + ::buffa::types::string_encoded_len(&self.where_sql) as u32;
6490 }
6491 if let Some(v) = self.since_sequence_number {
6492 size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
6493 }
6494 size += self.__buffa_unknown_fields.encoded_len() as u32;
6495 size
6496 }
6497 #[allow(clippy::needless_borrow)]
6498 fn write_to(
6499 &self,
6500 _cache: &mut ::buffa::SizeCache,
6501 buf: &mut impl ::buffa::bytes::BufMut,
6502 ) {
6503 #[allow(unused_imports)]
6504 use ::buffa::Enumeration as _;
6505 if !self.table.is_empty() {
6506 ::buffa::encoding::Tag::new(
6507 1u32,
6508 ::buffa::encoding::WireType::LengthDelimited,
6509 )
6510 .encode(buf);
6511 ::buffa::types::encode_string(&self.table, buf);
6512 }
6513 if !self.where_sql.is_empty() {
6514 ::buffa::encoding::Tag::new(
6515 2u32,
6516 ::buffa::encoding::WireType::LengthDelimited,
6517 )
6518 .encode(buf);
6519 ::buffa::types::encode_string(&self.where_sql, buf);
6520 }
6521 if let Some(v) = self.since_sequence_number {
6522 ::buffa::encoding::Tag::new(
6523 3u32,
6524 ::buffa::encoding::WireType::Varint,
6525 )
6526 .encode(buf);
6527 ::buffa::types::encode_uint64(v, buf);
6528 }
6529 self.__buffa_unknown_fields.write_to(buf);
6530 }
6531 }
6532 impl<'__a> ::serde::Serialize for SubscribeRequestView<'__a> {
6544 fn serialize<__S: ::serde::Serializer>(
6545 &self,
6546 __s: __S,
6547 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6548 use ::serde::ser::SerializeMap as _;
6549 let mut __map = __s.serialize_map(::core::option::Option::None)?;
6550 if !::buffa::json_helpers::skip_if::is_empty_str(self.table) {
6551 __map.serialize_entry("table", self.table)?;
6552 }
6553 if !::buffa::json_helpers::skip_if::is_empty_str(self.where_sql) {
6554 __map.serialize_entry("whereSql", self.where_sql)?;
6555 }
6556 if let ::core::option::Option::Some(__v) = self.since_sequence_number {
6557 struct _W(u64);
6558 impl ::serde::Serialize for _W {
6559 fn serialize<__S: ::serde::Serializer>(
6560 &self,
6561 __s: __S,
6562 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6563 ::buffa::json_helpers::uint64::serialize(&self.0, __s)
6564 }
6565 }
6566 __map.serialize_entry("sinceSequenceNumber", &_W(__v))?;
6567 }
6568 __map.end()
6569 }
6570 }
6571 impl<'a> ::buffa::MessageName for SubscribeRequestView<'a> {
6572 const PACKAGE: &'static str = "sql.v1";
6573 const NAME: &'static str = "SubscribeRequest";
6574 const FULL_NAME: &'static str = "sql.v1.SubscribeRequest";
6575 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeRequest";
6576 }
6577 impl<'v> ::buffa::DefaultViewInstance for SubscribeRequestView<'v> {
6578 fn default_view_instance<'a>() -> &'a Self
6579 where
6580 Self: 'a,
6581 {
6582 static VALUE: ::buffa::__private::OnceBox<
6583 SubscribeRequestView<'static>,
6584 > = ::buffa::__private::OnceBox::new();
6585 VALUE
6586 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6587 <SubscribeRequestView<'static>>::default(),
6588 ))
6589 }
6590 }
6591 impl ::buffa::ViewReborrow for SubscribeRequestView<'static> {
6592 type Reborrowed<'b> = SubscribeRequestView<'b>;
6593 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
6594 this
6595 }
6596 }
6597 #[derive(Clone, Debug, Default)]
6599 pub struct SubscribeResponseView<'a> {
6600 pub sequence_number: u64,
6605 pub column: ::buffa::RepeatedView<'a, &'a str>,
6609 pub rows: ::buffa::RepeatedView<
6614 'a,
6615 super::super::__buffa::view::RowView<'a>,
6616 >,
6617 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
6618 }
6619 impl<'a> SubscribeResponseView<'a> {
6620 #[doc(hidden)]
6628 pub fn _decode_depth(
6629 buf: &'a [u8],
6630 depth: u32,
6631 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6632 let mut view = Self::default();
6633 view._merge_into_view(buf, depth)?;
6634 ::core::result::Result::Ok(view)
6635 }
6636 #[doc(hidden)]
6644 pub fn _merge_into_view(
6645 &mut self,
6646 buf: &'a [u8],
6647 depth: u32,
6648 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6649 let _ = depth;
6650 #[allow(unused_variables)]
6651 let view = self;
6652 let mut cur: &'a [u8] = buf;
6653 while !cur.is_empty() {
6654 let before_tag = cur;
6655 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
6656 match tag.field_number() {
6657 1u32 => {
6658 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6659 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6660 field_number: 1u32,
6661 expected: 0u8,
6662 actual: tag.wire_type() as u8,
6663 });
6664 }
6665 view.sequence_number = ::buffa::types::decode_uint64(
6666 &mut cur,
6667 )?;
6668 }
6669 2u32 => {
6670 if tag.wire_type()
6671 != ::buffa::encoding::WireType::LengthDelimited
6672 {
6673 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6674 field_number: 2u32,
6675 expected: 2u8,
6676 actual: tag.wire_type() as u8,
6677 });
6678 }
6679 view.column.push(::buffa::types::borrow_str(&mut cur)?);
6680 }
6681 3u32 => {
6682 if tag.wire_type()
6683 != ::buffa::encoding::WireType::LengthDelimited
6684 {
6685 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6686 field_number: 3u32,
6687 expected: 2u8,
6688 actual: tag.wire_type() as u8,
6689 });
6690 }
6691 if depth == 0 {
6692 return Err(::buffa::DecodeError::RecursionLimitExceeded);
6693 }
6694 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
6695 view.rows
6696 .push(
6697 super::super::__buffa::view::RowView::_decode_depth(
6698 sub,
6699 depth - 1,
6700 )?,
6701 );
6702 }
6703 _ => {
6704 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
6705 let span_len = before_tag.len() - cur.len();
6706 view.__buffa_unknown_fields
6707 .push_raw(&before_tag[..span_len]);
6708 }
6709 }
6710 }
6711 ::core::result::Result::Ok(())
6712 }
6713 }
6714 impl<'a> ::buffa::MessageView<'a> for SubscribeResponseView<'a> {
6715 type Owned = super::super::SubscribeResponse;
6716 fn decode_view(
6717 buf: &'a [u8],
6718 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6719 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
6720 }
6721 fn decode_view_with_limit(
6722 buf: &'a [u8],
6723 depth: u32,
6724 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
6725 Self::_decode_depth(buf, depth)
6726 }
6727 fn to_owned_message(&self) -> super::super::SubscribeResponse {
6728 self.to_owned_from_source(None)
6729 }
6730 #[allow(clippy::useless_conversion, clippy::needless_update)]
6731 fn to_owned_from_source(
6732 &self,
6733 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
6734 ) -> super::super::SubscribeResponse {
6735 #[allow(unused_imports)]
6736 use ::buffa::alloc::string::ToString as _;
6737 let _ = __buffa_src;
6738 super::super::SubscribeResponse {
6739 sequence_number: self.sequence_number,
6740 column: self.column.iter().map(|s| s.to_string()).collect(),
6741 rows: self
6742 .rows
6743 .iter()
6744 .map(|v| v.to_owned_from_source(__buffa_src))
6745 .collect(),
6746 __buffa_unknown_fields: self
6747 .__buffa_unknown_fields
6748 .to_owned()
6749 .unwrap_or_default()
6750 .into(),
6751 ..::core::default::Default::default()
6752 }
6753 }
6754 }
6755 impl<'a> ::buffa::ViewEncode<'a> for SubscribeResponseView<'a> {
6756 #[allow(clippy::needless_borrow, clippy::let_and_return)]
6757 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
6758 #[allow(unused_imports)]
6759 use ::buffa::Enumeration as _;
6760 let mut size = 0u32;
6761 if self.sequence_number != 0u64 {
6762 size
6763 += 1u32
6764 + ::buffa::types::uint64_encoded_len(self.sequence_number)
6765 as u32;
6766 }
6767 for v in &self.column {
6768 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
6769 }
6770 for v in &self.rows {
6771 let __slot = __cache.reserve();
6772 let inner_size = v.compute_size(__cache);
6773 __cache.set(__slot, inner_size);
6774 size
6775 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
6776 + inner_size;
6777 }
6778 size += self.__buffa_unknown_fields.encoded_len() as u32;
6779 size
6780 }
6781 #[allow(clippy::needless_borrow)]
6782 fn write_to(
6783 &self,
6784 __cache: &mut ::buffa::SizeCache,
6785 buf: &mut impl ::buffa::bytes::BufMut,
6786 ) {
6787 #[allow(unused_imports)]
6788 use ::buffa::Enumeration as _;
6789 if self.sequence_number != 0u64 {
6790 ::buffa::encoding::Tag::new(
6791 1u32,
6792 ::buffa::encoding::WireType::Varint,
6793 )
6794 .encode(buf);
6795 ::buffa::types::encode_uint64(self.sequence_number, buf);
6796 }
6797 for v in &self.column {
6798 ::buffa::encoding::Tag::new(
6799 2u32,
6800 ::buffa::encoding::WireType::LengthDelimited,
6801 )
6802 .encode(buf);
6803 ::buffa::types::encode_string(v, buf);
6804 }
6805 for v in &self.rows {
6806 ::buffa::encoding::Tag::new(
6807 3u32,
6808 ::buffa::encoding::WireType::LengthDelimited,
6809 )
6810 .encode(buf);
6811 ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
6812 v.write_to(__cache, buf);
6813 }
6814 self.__buffa_unknown_fields.write_to(buf);
6815 }
6816 }
6817 impl<'__a> ::serde::Serialize for SubscribeResponseView<'__a> {
6829 fn serialize<__S: ::serde::Serializer>(
6830 &self,
6831 __s: __S,
6832 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6833 use ::serde::ser::SerializeMap as _;
6834 let mut __map = __s.serialize_map(::core::option::Option::None)?;
6835 if !::buffa::json_helpers::skip_if::is_zero_u64(&self.sequence_number) {
6836 struct _W(u64);
6837 impl ::serde::Serialize for _W {
6838 fn serialize<__S: ::serde::Serializer>(
6839 &self,
6840 __s: __S,
6841 ) -> ::core::result::Result<__S::Ok, __S::Error> {
6842 ::buffa::json_helpers::uint64::serialize(&self.0, __s)
6843 }
6844 }
6845 __map.serialize_entry("sequenceNumber", &_W(self.sequence_number))?;
6846 }
6847 if !self.column.is_empty() {
6848 __map.serialize_entry("column", &*self.column)?;
6849 }
6850 if !self.rows.is_empty() {
6851 __map.serialize_entry("rows", &*self.rows)?;
6852 }
6853 __map.end()
6854 }
6855 }
6856 impl<'a> ::buffa::MessageName for SubscribeResponseView<'a> {
6857 const PACKAGE: &'static str = "sql.v1";
6858 const NAME: &'static str = "SubscribeResponse";
6859 const FULL_NAME: &'static str = "sql.v1.SubscribeResponse";
6860 const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeResponse";
6861 }
6862 impl<'v> ::buffa::DefaultViewInstance for SubscribeResponseView<'v> {
6863 fn default_view_instance<'a>() -> &'a Self
6864 where
6865 Self: 'a,
6866 {
6867 static VALUE: ::buffa::__private::OnceBox<
6868 SubscribeResponseView<'static>,
6869 > = ::buffa::__private::OnceBox::new();
6870 VALUE
6871 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6872 <SubscribeResponseView<'static>>::default(),
6873 ))
6874 }
6875 }
6876 impl ::buffa::ViewReborrow for SubscribeResponseView<'static> {
6877 type Reborrowed<'b> = SubscribeResponseView<'b>;
6878 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
6879 this
6880 }
6881 }
6882 pub mod oneof {
6883 #[allow(unused_imports)]
6884 use super::*;
6885 pub mod cell {
6886 #[allow(unused_imports)]
6887 use super::*;
6888 #[derive(Clone, Debug)]
6889 pub enum Kind<'a> {
6890 NullValue(
6891 ::buffa::alloc::boxed::Box<
6892 super::super::super::super::__buffa::view::NullView<'a>,
6893 >,
6894 ),
6895 Int64Value(i64),
6896 Uint64Value(u64),
6897 Float64Value(f64),
6898 BooleanValue(bool),
6899 Utf8Value(&'a str),
6900 FixedSizeBinaryValue(&'a [u8]),
6901 Date32Value(i32),
6902 Date64Value(i64),
6903 TimestampValue(i64),
6904 Decimal128Value(&'a [u8]),
6905 Decimal256Value(&'a [u8]),
6906 ListValue(
6907 ::buffa::alloc::boxed::Box<
6908 super::super::super::super::__buffa::view::ListValueView<'a>,
6909 >,
6910 ),
6911 }
6912 }
6913 }
6914 }
6915 pub mod oneof {
6916 #[allow(unused_imports)]
6917 use super::*;
6918 pub mod cell {
6919 #[allow(unused_imports)]
6920 use super::*;
6921 #[derive(Clone, PartialEq, Debug)]
6922 pub enum Kind {
6923 NullValue(::buffa::alloc::boxed::Box<super::super::super::Null>),
6924 Int64Value(i64),
6925 Uint64Value(u64),
6926 Float64Value(f64),
6927 BooleanValue(bool),
6928 Utf8Value(::buffa::alloc::string::String),
6929 FixedSizeBinaryValue(::buffa::bytes::Bytes),
6930 Date32Value(i32),
6931 Date64Value(i64),
6932 TimestampValue(i64),
6933 Decimal128Value(::buffa::bytes::Bytes),
6934 Decimal256Value(::buffa::bytes::Bytes),
6935 ListValue(::buffa::alloc::boxed::Box<super::super::super::ListValue>),
6936 }
6937 impl ::buffa::Oneof for Kind {}
6938 impl From<super::super::super::Null> for Kind {
6939 fn from(v: super::super::super::Null) -> Self {
6940 Self::NullValue(::buffa::alloc::boxed::Box::new(v))
6941 }
6942 }
6943 impl From<super::super::super::Null> for ::core::option::Option<Kind> {
6944 fn from(v: super::super::super::Null) -> Self {
6945 Self::Some(Kind::from(v))
6946 }
6947 }
6948 impl From<super::super::super::ListValue> for Kind {
6949 fn from(v: super::super::super::ListValue) -> Self {
6950 Self::ListValue(::buffa::alloc::boxed::Box::new(v))
6951 }
6952 }
6953 impl From<super::super::super::ListValue> for ::core::option::Option<Kind> {
6954 fn from(v: super::super::super::ListValue) -> Self {
6955 Self::Some(Kind::from(v))
6956 }
6957 }
6958 impl serde::Serialize for Kind {
6959 fn serialize<S: serde::Serializer>(
6960 &self,
6961 s: S,
6962 ) -> ::core::result::Result<S::Ok, S::Error> {
6963 use serde::ser::SerializeMap;
6964 let mut map = s.serialize_map(Some(1))?;
6965 match self {
6966 Self::NullValue(v) => {
6967 map.serialize_entry("nullValue", v)?;
6968 }
6969 Self::Int64Value(v) => {
6970 struct _W<'a>(&'a i64);
6971 impl serde::Serialize for _W<'_> {
6972 fn serialize<S2: serde::Serializer>(
6973 &self,
6974 s: S2,
6975 ) -> ::core::result::Result<S2::Ok, S2::Error> {
6976 ::buffa::json_helpers::int64::serialize(self.0, s)
6977 }
6978 }
6979 map.serialize_entry("int64Value", &_W(v))?;
6980 }
6981 Self::Uint64Value(v) => {
6982 struct _W<'a>(&'a u64);
6983 impl serde::Serialize for _W<'_> {
6984 fn serialize<S2: serde::Serializer>(
6985 &self,
6986 s: S2,
6987 ) -> ::core::result::Result<S2::Ok, S2::Error> {
6988 ::buffa::json_helpers::uint64::serialize(self.0, s)
6989 }
6990 }
6991 map.serialize_entry("uint64Value", &_W(v))?;
6992 }
6993 Self::Float64Value(v) => {
6994 struct _W<'a>(&'a f64);
6995 impl serde::Serialize for _W<'_> {
6996 fn serialize<S2: serde::Serializer>(
6997 &self,
6998 s: S2,
6999 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7000 ::buffa::json_helpers::double::serialize(self.0, s)
7001 }
7002 }
7003 map.serialize_entry("float64Value", &_W(v))?;
7004 }
7005 Self::BooleanValue(v) => {
7006 map.serialize_entry("booleanValue", v)?;
7007 }
7008 Self::Utf8Value(v) => {
7009 map.serialize_entry("utf8Value", v)?;
7010 }
7011 Self::FixedSizeBinaryValue(v) => {
7012 struct _W<'a>(&'a ::buffa::bytes::Bytes);
7013 impl serde::Serialize for _W<'_> {
7014 fn serialize<S2: serde::Serializer>(
7015 &self,
7016 s: S2,
7017 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7018 ::buffa::json_helpers::bytes::serialize(self.0, s)
7019 }
7020 }
7021 map.serialize_entry("fixedSizeBinaryValue", &_W(v))?;
7022 }
7023 Self::Date32Value(v) => {
7024 struct _W<'a>(&'a i32);
7025 impl serde::Serialize for _W<'_> {
7026 fn serialize<S2: serde::Serializer>(
7027 &self,
7028 s: S2,
7029 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7030 ::buffa::json_helpers::int32::serialize(self.0, s)
7031 }
7032 }
7033 map.serialize_entry("date32Value", &_W(v))?;
7034 }
7035 Self::Date64Value(v) => {
7036 struct _W<'a>(&'a i64);
7037 impl serde::Serialize for _W<'_> {
7038 fn serialize<S2: serde::Serializer>(
7039 &self,
7040 s: S2,
7041 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7042 ::buffa::json_helpers::int64::serialize(self.0, s)
7043 }
7044 }
7045 map.serialize_entry("date64Value", &_W(v))?;
7046 }
7047 Self::TimestampValue(v) => {
7048 struct _W<'a>(&'a i64);
7049 impl serde::Serialize for _W<'_> {
7050 fn serialize<S2: serde::Serializer>(
7051 &self,
7052 s: S2,
7053 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7054 ::buffa::json_helpers::int64::serialize(self.0, s)
7055 }
7056 }
7057 map.serialize_entry("timestampValue", &_W(v))?;
7058 }
7059 Self::Decimal128Value(v) => {
7060 struct _W<'a>(&'a ::buffa::bytes::Bytes);
7061 impl serde::Serialize for _W<'_> {
7062 fn serialize<S2: serde::Serializer>(
7063 &self,
7064 s: S2,
7065 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7066 ::buffa::json_helpers::bytes::serialize(self.0, s)
7067 }
7068 }
7069 map.serialize_entry("decimal128Value", &_W(v))?;
7070 }
7071 Self::Decimal256Value(v) => {
7072 struct _W<'a>(&'a ::buffa::bytes::Bytes);
7073 impl serde::Serialize for _W<'_> {
7074 fn serialize<S2: serde::Serializer>(
7075 &self,
7076 s: S2,
7077 ) -> ::core::result::Result<S2::Ok, S2::Error> {
7078 ::buffa::json_helpers::bytes::serialize(self.0, s)
7079 }
7080 }
7081 map.serialize_entry("decimal256Value", &_W(v))?;
7082 }
7083 Self::ListValue(v) => {
7084 map.serialize_entry("listValue", v)?;
7085 }
7086 }
7087 map.end()
7088 }
7089 }
7090 }
7091 }
7092}
7093#[doc(inline)]
7094pub use self::__buffa::view::RowView;
7095#[doc(inline)]
7096pub use self::__buffa::view::NullView;
7097#[doc(inline)]
7098pub use self::__buffa::view::ListValueView;
7099#[doc(inline)]
7100pub use self::__buffa::view::CellView;
7101#[doc(inline)]
7102pub use self::__buffa::view::TablesResponseView;
7103#[doc(inline)]
7104pub use self::__buffa::view::TablesRequestView;
7105#[doc(inline)]
7106pub use self::__buffa::view::TableView;
7107#[doc(inline)]
7108pub use self::__buffa::view::ColumnView;
7109#[doc(inline)]
7110pub use self::__buffa::view::IndexView;
7111#[doc(inline)]
7112pub use self::__buffa::view::QueryRequestView;
7113#[doc(inline)]
7114pub use self::__buffa::view::QueryResponseView;
7115#[doc(inline)]
7116pub use self::__buffa::view::SubscribeRequestView;
7117#[doc(inline)]
7118pub use self::__buffa::view::SubscribeResponseView;
7119
7120pub type OwnedSubscribeRequestView = ::buffa::view::OwnedView<
7122 __buffa::view::SubscribeRequestView<'static>,
7123>;
7124pub type OwnedSubscribeResponseView = ::buffa::view::OwnedView<
7126 __buffa::view::SubscribeResponseView<'static>,
7127>;
7128pub type OwnedQueryRequestView = ::buffa::view::OwnedView<
7130 __buffa::view::QueryRequestView<'static>,
7131>;
7132pub type OwnedQueryResponseView = ::buffa::view::OwnedView<
7134 __buffa::view::QueryResponseView<'static>,
7135>;
7136pub type OwnedTablesRequestView = ::buffa::view::OwnedView<
7138 __buffa::view::TablesRequestView<'static>,
7139>;
7140pub type OwnedTablesResponseView = ::buffa::view::OwnedView<
7142 __buffa::view::TablesResponseView<'static>,
7143>;
7144impl ::connectrpc::Encodable<SubscribeResponse>
7145for __buffa::view::SubscribeResponseView<'_> {
7146 fn encode(
7147 &self,
7148 codec: ::connectrpc::CodecFormat,
7149 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7150 ::connectrpc::__codegen::encode_view_body(self, codec)
7151 }
7152}
7153impl ::connectrpc::Encodable<SubscribeResponse>
7154for ::buffa::view::OwnedView<__buffa::view::SubscribeResponseView<'static>> {
7155 fn encode(
7156 &self,
7157 codec: ::connectrpc::CodecFormat,
7158 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7159 ::connectrpc::__codegen::encode_view_body(&**self, codec)
7160 }
7161}
7162impl ::connectrpc::Encodable<QueryResponse> for __buffa::view::QueryResponseView<'_> {
7163 fn encode(
7164 &self,
7165 codec: ::connectrpc::CodecFormat,
7166 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7167 ::connectrpc::__codegen::encode_view_body(self, codec)
7168 }
7169}
7170impl ::connectrpc::Encodable<QueryResponse>
7171for ::buffa::view::OwnedView<__buffa::view::QueryResponseView<'static>> {
7172 fn encode(
7173 &self,
7174 codec: ::connectrpc::CodecFormat,
7175 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7176 ::connectrpc::__codegen::encode_view_body(&**self, codec)
7177 }
7178}
7179impl ::connectrpc::Encodable<TablesResponse> for __buffa::view::TablesResponseView<'_> {
7180 fn encode(
7181 &self,
7182 codec: ::connectrpc::CodecFormat,
7183 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7184 ::connectrpc::__codegen::encode_view_body(self, codec)
7185 }
7186}
7187impl ::connectrpc::Encodable<TablesResponse>
7188for ::buffa::view::OwnedView<__buffa::view::TablesResponseView<'static>> {
7189 fn encode(
7190 &self,
7191 codec: ::connectrpc::CodecFormat,
7192 ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
7193 ::connectrpc::__codegen::encode_view_body(&**self, codec)
7194 }
7195}
7196pub const SERVICE_SERVICE_NAME: &str = "sql.v1.Service";
7198pub const SERVICE_SUBSCRIBE_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
7203 "/sql.v1.Service/Subscribe",
7204 ::connectrpc::StreamType::ServerStream,
7205 )
7206 .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
7207pub const SERVICE_QUERY_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
7212 "/sql.v1.Service/Query",
7213 ::connectrpc::StreamType::Unary,
7214 )
7215 .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
7216pub const SERVICE_TABLES_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
7221 "/sql.v1.Service/Tables",
7222 ::connectrpc::StreamType::Unary,
7223 )
7224 .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
7225#[allow(clippy::type_complexity)]
7263pub trait Service: Send + Sync + 'static {
7264 fn subscribe(
7268 &self,
7269 ctx: ::connectrpc::RequestContext,
7270 request: OwnedSubscribeRequestView,
7271 ) -> impl ::std::future::Future<
7272 Output = ::connectrpc::ServiceResult<
7273 ::connectrpc::ServiceStream<
7274 impl ::connectrpc::Encodable<SubscribeResponse> + Send + use<Self>,
7275 >,
7276 >,
7277 > + Send;
7278 fn query<'a>(
7283 &'a self,
7284 ctx: ::connectrpc::RequestContext,
7285 request: OwnedQueryRequestView,
7286 ) -> impl ::std::future::Future<
7287 Output = ::connectrpc::ServiceResult<
7288 impl ::connectrpc::Encodable<QueryResponse> + Send + use<'a, Self>,
7289 >,
7290 > + Send;
7291 fn tables<'a>(
7297 &'a self,
7298 ctx: ::connectrpc::RequestContext,
7299 request: OwnedTablesRequestView,
7300 ) -> impl ::std::future::Future<
7301 Output = ::connectrpc::ServiceResult<
7302 impl ::connectrpc::Encodable<TablesResponse> + Send + use<'a, Self>,
7303 >,
7304 > + Send;
7305}
7306pub trait ServiceExt: Service {
7319 fn register(
7324 self: ::std::sync::Arc<Self>,
7325 router: ::connectrpc::Router,
7326 ) -> ::connectrpc::Router;
7327}
7328impl<S: Service> ServiceExt for S {
7329 fn register(
7330 self: ::std::sync::Arc<Self>,
7331 router: ::connectrpc::Router,
7332 ) -> ::connectrpc::Router {
7333 router
7334 .route_view_server_stream::<
7335 _,
7336 _,
7337 SubscribeResponse,
7338 >(
7339 SERVICE_SERVICE_NAME,
7340 "Subscribe",
7341 ::connectrpc::view_streaming_handler_fn({
7342 let svc = ::std::sync::Arc::clone(&self);
7343 move |ctx, req| {
7344 let svc = ::std::sync::Arc::clone(&svc);
7345 async move { svc.subscribe(ctx, req).await }
7346 }
7347 }),
7348 )
7349 .with_spec(SERVICE_SUBSCRIBE_SPEC)
7350 .route_view(
7351 SERVICE_SERVICE_NAME,
7352 "Query",
7353 {
7354 let svc = ::std::sync::Arc::clone(&self);
7355 ::connectrpc::view_handler_fn(move |ctx, req, format| {
7356 let svc = ::std::sync::Arc::clone(&svc);
7357 async move {
7358 svc.query(ctx, req).await?.encode::<QueryResponse>(format)
7359 }
7360 })
7361 },
7362 )
7363 .with_spec(SERVICE_QUERY_SPEC)
7364 .route_view(
7365 SERVICE_SERVICE_NAME,
7366 "Tables",
7367 {
7368 let svc = ::std::sync::Arc::clone(&self);
7369 ::connectrpc::view_handler_fn(move |ctx, req, format| {
7370 let svc = ::std::sync::Arc::clone(&svc);
7371 async move {
7372 svc.tables(ctx, req).await?.encode::<TablesResponse>(format)
7373 }
7374 })
7375 },
7376 )
7377 .with_spec(SERVICE_TABLES_SPEC)
7378 }
7379}
7380pub struct ServiceServer<T> {
7394 inner: ::std::sync::Arc<T>,
7395}
7396impl<T: Service> ServiceServer<T> {
7397 pub fn new(service: T) -> Self {
7399 Self {
7400 inner: ::std::sync::Arc::new(service),
7401 }
7402 }
7403 pub fn from_arc(inner: ::std::sync::Arc<T>) -> Self {
7405 Self { inner }
7406 }
7407}
7408impl<T> Clone for ServiceServer<T> {
7409 fn clone(&self) -> Self {
7410 Self {
7411 inner: ::std::sync::Arc::clone(&self.inner),
7412 }
7413 }
7414}
7415impl<T: Service> ::connectrpc::Dispatcher for ServiceServer<T> {
7416 #[inline]
7417 fn lookup(
7418 &self,
7419 path: &str,
7420 ) -> Option<::connectrpc::dispatcher::codegen::MethodDescriptor> {
7421 let method = path.strip_prefix("sql.v1.Service/")?;
7422 match method {
7423 "Subscribe" => {
7424 Some(
7425 ::connectrpc::dispatcher::codegen::MethodDescriptor::server_streaming()
7426 .with_spec(SERVICE_SUBSCRIBE_SPEC),
7427 )
7428 }
7429 "Query" => {
7430 Some(
7431 ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
7432 .with_spec(SERVICE_QUERY_SPEC),
7433 )
7434 }
7435 "Tables" => {
7436 Some(
7437 ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
7438 .with_spec(SERVICE_TABLES_SPEC),
7439 )
7440 }
7441 _ => None,
7442 }
7443 }
7444 fn call_unary(
7445 &self,
7446 path: &str,
7447 ctx: ::connectrpc::RequestContext,
7448 request: ::connectrpc::Payload,
7449 format: ::connectrpc::CodecFormat,
7450 ) -> ::connectrpc::dispatcher::codegen::UnaryResult {
7451 let Some(method) = path.strip_prefix("sql.v1.Service/") else {
7452 return ::connectrpc::dispatcher::codegen::unimplemented_unary(path);
7453 };
7454 let _ = (&ctx, &request, &format);
7455 match method {
7456 "Query" => {
7457 let svc = ::std::sync::Arc::clone(&self.inner);
7458 Box::pin(async move {
7459 let req = ::connectrpc::dispatcher::codegen::decode_request_view::<
7460 __buffa::view::QueryRequestView,
7461 >(request.encoded()?, format)?;
7462 svc.query(ctx, req).await?.encode::<QueryResponse>(format)
7463 })
7464 }
7465 "Tables" => {
7466 let svc = ::std::sync::Arc::clone(&self.inner);
7467 Box::pin(async move {
7468 let req = ::connectrpc::dispatcher::codegen::decode_request_view::<
7469 __buffa::view::TablesRequestView,
7470 >(request.encoded()?, format)?;
7471 svc.tables(ctx, req).await?.encode::<TablesResponse>(format)
7472 })
7473 }
7474 _ => ::connectrpc::dispatcher::codegen::unimplemented_unary(path),
7475 }
7476 }
7477 fn call_server_streaming(
7478 &self,
7479 path: &str,
7480 ctx: ::connectrpc::RequestContext,
7481 request: ::buffa::bytes::Bytes,
7482 format: ::connectrpc::CodecFormat,
7483 ) -> ::connectrpc::dispatcher::codegen::StreamingResult {
7484 let Some(method) = path.strip_prefix("sql.v1.Service/") else {
7485 return ::connectrpc::dispatcher::codegen::unimplemented_streaming(path);
7486 };
7487 let _ = (&ctx, &request, &format);
7488 match method {
7489 "Subscribe" => {
7490 let svc = ::std::sync::Arc::clone(&self.inner);
7491 Box::pin(async move {
7492 let req = ::connectrpc::dispatcher::codegen::decode_request_view::<
7493 __buffa::view::SubscribeRequestView,
7494 >(request, format)?;
7495 let resp = svc.subscribe(ctx, req).await?;
7496 Ok(
7497 resp
7498 .map_body(|s| ::connectrpc::dispatcher::codegen::encode_response_stream::<
7499 SubscribeResponse,
7500 _,
7501 _,
7502 >(s, format)),
7503 )
7504 })
7505 }
7506 _ => ::connectrpc::dispatcher::codegen::unimplemented_streaming(path),
7507 }
7508 }
7509 fn call_client_streaming(
7510 &self,
7511 path: &str,
7512 ctx: ::connectrpc::RequestContext,
7513 requests: ::connectrpc::dispatcher::codegen::RequestStream,
7514 format: ::connectrpc::CodecFormat,
7515 ) -> ::connectrpc::dispatcher::codegen::UnaryResult {
7516 let Some(method) = path.strip_prefix("sql.v1.Service/") else {
7517 return ::connectrpc::dispatcher::codegen::unimplemented_unary(path);
7518 };
7519 let _ = (&ctx, &requests, &format);
7520 match method {
7521 _ => ::connectrpc::dispatcher::codegen::unimplemented_unary(path),
7522 }
7523 }
7524 fn call_bidi_streaming(
7525 &self,
7526 path: &str,
7527 ctx: ::connectrpc::RequestContext,
7528 requests: ::connectrpc::dispatcher::codegen::RequestStream,
7529 format: ::connectrpc::CodecFormat,
7530 ) -> ::connectrpc::dispatcher::codegen::StreamingResult {
7531 let Some(method) = path.strip_prefix("sql.v1.Service/") else {
7532 return ::connectrpc::dispatcher::codegen::unimplemented_streaming(path);
7533 };
7534 let _ = (&ctx, &requests, &format);
7535 match method {
7536 _ => ::connectrpc::dispatcher::codegen::unimplemented_streaming(path),
7537 }
7538 }
7539}
7540#[derive(Clone)]
7590pub struct ServiceClient<T> {
7591 transport: T,
7592 config: ::connectrpc::client::ClientConfig,
7593}
7594impl<T> ServiceClient<T>
7595where
7596 T: ::connectrpc::client::ClientTransport,
7597 <T::ResponseBody as ::http_body::Body>::Error: ::std::fmt::Display,
7598{
7599 pub fn new(transport: T, config: ::connectrpc::client::ClientConfig) -> Self {
7601 Self { transport, config }
7602 }
7603 pub fn config(&self) -> &::connectrpc::client::ClientConfig {
7605 &self.config
7606 }
7607 pub fn config_mut(&mut self) -> &mut ::connectrpc::client::ClientConfig {
7609 &mut self.config
7610 }
7611 pub async fn subscribe(
7613 &self,
7614 request: SubscribeRequest,
7615 ) -> Result<
7616 ::connectrpc::client::ServerStream<
7617 T::ResponseBody,
7618 __buffa::view::SubscribeResponseView<'static>,
7619 >,
7620 ::connectrpc::ConnectError,
7621 > {
7622 self.subscribe_with_options(
7623 request,
7624 ::connectrpc::client::CallOptions::default(),
7625 )
7626 .await
7627 }
7628 pub async fn subscribe_with_options(
7630 &self,
7631 request: SubscribeRequest,
7632 options: ::connectrpc::client::CallOptions,
7633 ) -> Result<
7634 ::connectrpc::client::ServerStream<
7635 T::ResponseBody,
7636 __buffa::view::SubscribeResponseView<'static>,
7637 >,
7638 ::connectrpc::ConnectError,
7639 > {
7640 ::connectrpc::client::call_server_stream(
7641 &self.transport,
7642 &self.config,
7643 SERVICE_SERVICE_NAME,
7644 "Subscribe",
7645 request,
7646 options,
7647 )
7648 .await
7649 }
7650 pub async fn query(
7652 &self,
7653 request: QueryRequest,
7654 ) -> Result<
7655 ::connectrpc::client::UnaryResponse<
7656 ::buffa::view::OwnedView<__buffa::view::QueryResponseView<'static>>,
7657 >,
7658 ::connectrpc::ConnectError,
7659 > {
7660 self.query_with_options(request, ::connectrpc::client::CallOptions::default())
7661 .await
7662 }
7663 pub async fn query_with_options(
7665 &self,
7666 request: QueryRequest,
7667 options: ::connectrpc::client::CallOptions,
7668 ) -> Result<
7669 ::connectrpc::client::UnaryResponse<
7670 ::buffa::view::OwnedView<__buffa::view::QueryResponseView<'static>>,
7671 >,
7672 ::connectrpc::ConnectError,
7673 > {
7674 ::connectrpc::client::call_unary(
7675 &self.transport,
7676 &self.config,
7677 SERVICE_SERVICE_NAME,
7678 "Query",
7679 request,
7680 options,
7681 )
7682 .await
7683 }
7684 pub async fn tables(
7686 &self,
7687 request: TablesRequest,
7688 ) -> Result<
7689 ::connectrpc::client::UnaryResponse<
7690 ::buffa::view::OwnedView<__buffa::view::TablesResponseView<'static>>,
7691 >,
7692 ::connectrpc::ConnectError,
7693 > {
7694 self.tables_with_options(request, ::connectrpc::client::CallOptions::default())
7695 .await
7696 }
7697 pub async fn tables_with_options(
7699 &self,
7700 request: TablesRequest,
7701 options: ::connectrpc::client::CallOptions,
7702 ) -> Result<
7703 ::connectrpc::client::UnaryResponse<
7704 ::buffa::view::OwnedView<__buffa::view::TablesResponseView<'static>>,
7705 >,
7706 ::connectrpc::ConnectError,
7707 > {
7708 ::connectrpc::client::call_unary(
7709 &self.transport,
7710 &self.config,
7711 SERVICE_SERVICE_NAME,
7712 "Tables",
7713 request,
7714 options,
7715 )
7716 .await
7717 }
7718}