1#![allow(unknown_lints)]
6#![allow(clippy::all)]
7
8#![allow(unused_attributes)]
9#![cfg_attr(rustfmt, rustfmt::skip)]
10
11#![allow(box_pointers)]
12#![allow(dead_code)]
13#![allow(missing_docs)]
14#![allow(non_camel_case_types)]
15#![allow(non_snake_case)]
16#![allow(non_upper_case_globals)]
17#![allow(trivial_casts)]
18#![allow(unused_imports)]
19#![allow(unused_results)]
20#[derive(PartialEq,Clone,Default)]
27pub struct TransactionOptions {
28 pub mode: ::std::option::Option<TransactionOptions_oneof_mode>,
30 pub unknown_fields: ::protobuf::UnknownFields,
32 pub cached_size: ::protobuf::CachedSize,
33}
34
35impl<'a> ::std::default::Default for &'a TransactionOptions {
36 fn default() -> &'a TransactionOptions {
37 <TransactionOptions as ::protobuf::Message>::default_instance()
38 }
39}
40
41#[derive(Clone,PartialEq,Debug)]
42pub enum TransactionOptions_oneof_mode {
43 read_write(TransactionOptions_ReadWrite),
44 partitioned_dml(TransactionOptions_PartitionedDml),
45 read_only(TransactionOptions_ReadOnly),
46}
47
48impl TransactionOptions {
49 pub fn new() -> TransactionOptions {
50 ::std::default::Default::default()
51 }
52
53 pub fn get_read_write(&self) -> &TransactionOptions_ReadWrite {
57 match self.mode {
58 ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(ref v)) => v,
59 _ => <TransactionOptions_ReadWrite as ::protobuf::Message>::default_instance(),
60 }
61 }
62 pub fn clear_read_write(&mut self) {
63 self.mode = ::std::option::Option::None;
64 }
65
66 pub fn has_read_write(&self) -> bool {
67 match self.mode {
68 ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(..)) => true,
69 _ => false,
70 }
71 }
72
73 pub fn set_read_write(&mut self, v: TransactionOptions_ReadWrite) {
75 self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(v))
76 }
77
78 pub fn mut_read_write(&mut self) -> &mut TransactionOptions_ReadWrite {
80 if let ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(_)) = self.mode {
81 } else {
82 self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(TransactionOptions_ReadWrite::new()));
83 }
84 match self.mode {
85 ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(ref mut v)) => v,
86 _ => panic!(),
87 }
88 }
89
90 pub fn take_read_write(&mut self) -> TransactionOptions_ReadWrite {
92 if self.has_read_write() {
93 match self.mode.take() {
94 ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(v)) => v,
95 _ => panic!(),
96 }
97 } else {
98 TransactionOptions_ReadWrite::new()
99 }
100 }
101
102 pub fn get_partitioned_dml(&self) -> &TransactionOptions_PartitionedDml {
106 match self.mode {
107 ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(ref v)) => v,
108 _ => <TransactionOptions_PartitionedDml as ::protobuf::Message>::default_instance(),
109 }
110 }
111 pub fn clear_partitioned_dml(&mut self) {
112 self.mode = ::std::option::Option::None;
113 }
114
115 pub fn has_partitioned_dml(&self) -> bool {
116 match self.mode {
117 ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(..)) => true,
118 _ => false,
119 }
120 }
121
122 pub fn set_partitioned_dml(&mut self, v: TransactionOptions_PartitionedDml) {
124 self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(v))
125 }
126
127 pub fn mut_partitioned_dml(&mut self) -> &mut TransactionOptions_PartitionedDml {
129 if let ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(_)) = self.mode {
130 } else {
131 self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(TransactionOptions_PartitionedDml::new()));
132 }
133 match self.mode {
134 ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(ref mut v)) => v,
135 _ => panic!(),
136 }
137 }
138
139 pub fn take_partitioned_dml(&mut self) -> TransactionOptions_PartitionedDml {
141 if self.has_partitioned_dml() {
142 match self.mode.take() {
143 ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(v)) => v,
144 _ => panic!(),
145 }
146 } else {
147 TransactionOptions_PartitionedDml::new()
148 }
149 }
150
151 pub fn get_read_only(&self) -> &TransactionOptions_ReadOnly {
155 match self.mode {
156 ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(ref v)) => v,
157 _ => <TransactionOptions_ReadOnly as ::protobuf::Message>::default_instance(),
158 }
159 }
160 pub fn clear_read_only(&mut self) {
161 self.mode = ::std::option::Option::None;
162 }
163
164 pub fn has_read_only(&self) -> bool {
165 match self.mode {
166 ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(..)) => true,
167 _ => false,
168 }
169 }
170
171 pub fn set_read_only(&mut self, v: TransactionOptions_ReadOnly) {
173 self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(v))
174 }
175
176 pub fn mut_read_only(&mut self) -> &mut TransactionOptions_ReadOnly {
178 if let ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(_)) = self.mode {
179 } else {
180 self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(TransactionOptions_ReadOnly::new()));
181 }
182 match self.mode {
183 ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(ref mut v)) => v,
184 _ => panic!(),
185 }
186 }
187
188 pub fn take_read_only(&mut self) -> TransactionOptions_ReadOnly {
190 if self.has_read_only() {
191 match self.mode.take() {
192 ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(v)) => v,
193 _ => panic!(),
194 }
195 } else {
196 TransactionOptions_ReadOnly::new()
197 }
198 }
199}
200
201impl ::protobuf::Message for TransactionOptions {
202 fn is_initialized(&self) -> bool {
203 if let Some(TransactionOptions_oneof_mode::read_write(ref v)) = self.mode {
204 if !v.is_initialized() {
205 return false;
206 }
207 }
208 if let Some(TransactionOptions_oneof_mode::partitioned_dml(ref v)) = self.mode {
209 if !v.is_initialized() {
210 return false;
211 }
212 }
213 if let Some(TransactionOptions_oneof_mode::read_only(ref v)) = self.mode {
214 if !v.is_initialized() {
215 return false;
216 }
217 }
218 true
219 }
220
221 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
222 while !is.eof()? {
223 let (field_number, wire_type) = is.read_tag_unpack()?;
224 match field_number {
225 1 => {
226 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
227 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
228 }
229 self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(is.read_message()?));
230 },
231 3 => {
232 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
233 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
234 }
235 self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(is.read_message()?));
236 },
237 2 => {
238 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
239 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
240 }
241 self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(is.read_message()?));
242 },
243 _ => {
244 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
245 },
246 };
247 }
248 ::std::result::Result::Ok(())
249 }
250
251 #[allow(unused_variables)]
253 fn compute_size(&self) -> u32 {
254 let mut my_size = 0;
255 if let ::std::option::Option::Some(ref v) = self.mode {
256 match v {
257 &TransactionOptions_oneof_mode::read_write(ref v) => {
258 let len = v.compute_size();
259 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
260 },
261 &TransactionOptions_oneof_mode::partitioned_dml(ref v) => {
262 let len = v.compute_size();
263 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
264 },
265 &TransactionOptions_oneof_mode::read_only(ref v) => {
266 let len = v.compute_size();
267 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
268 },
269 };
270 }
271 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
272 self.cached_size.set(my_size);
273 my_size
274 }
275
276 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
277 if let ::std::option::Option::Some(ref v) = self.mode {
278 match v {
279 &TransactionOptions_oneof_mode::read_write(ref v) => {
280 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
281 os.write_raw_varint32(v.get_cached_size())?;
282 v.write_to_with_cached_sizes(os)?;
283 },
284 &TransactionOptions_oneof_mode::partitioned_dml(ref v) => {
285 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
286 os.write_raw_varint32(v.get_cached_size())?;
287 v.write_to_with_cached_sizes(os)?;
288 },
289 &TransactionOptions_oneof_mode::read_only(ref v) => {
290 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
291 os.write_raw_varint32(v.get_cached_size())?;
292 v.write_to_with_cached_sizes(os)?;
293 },
294 };
295 }
296 os.write_unknown_fields(self.get_unknown_fields())?;
297 ::std::result::Result::Ok(())
298 }
299
300 fn get_cached_size(&self) -> u32 {
301 self.cached_size.get()
302 }
303
304 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
305 &self.unknown_fields
306 }
307
308 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
309 &mut self.unknown_fields
310 }
311
312 fn as_any(&self) -> &dyn (::std::any::Any) {
313 self as &dyn (::std::any::Any)
314 }
315 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
316 self as &mut dyn (::std::any::Any)
317 }
318 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
319 self
320 }
321
322 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
323 Self::descriptor_static()
324 }
325
326 fn new() -> TransactionOptions {
327 TransactionOptions::new()
328 }
329
330 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
331 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
332 descriptor.get(|| {
333 let mut fields = ::std::vec::Vec::new();
334 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions_ReadWrite>(
335 "read_write",
336 TransactionOptions::has_read_write,
337 TransactionOptions::get_read_write,
338 ));
339 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions_PartitionedDml>(
340 "partitioned_dml",
341 TransactionOptions::has_partitioned_dml,
342 TransactionOptions::get_partitioned_dml,
343 ));
344 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions_ReadOnly>(
345 "read_only",
346 TransactionOptions::has_read_only,
347 TransactionOptions::get_read_only,
348 ));
349 ::protobuf::reflect::MessageDescriptor::new_pb_name::<TransactionOptions>(
350 "TransactionOptions",
351 fields,
352 file_descriptor_proto()
353 )
354 })
355 }
356
357 fn default_instance() -> &'static TransactionOptions {
358 static instance: ::protobuf::rt::LazyV2<TransactionOptions> = ::protobuf::rt::LazyV2::INIT;
359 instance.get(TransactionOptions::new)
360 }
361}
362
363impl ::protobuf::Clear for TransactionOptions {
364 fn clear(&mut self) {
365 self.mode = ::std::option::Option::None;
366 self.mode = ::std::option::Option::None;
367 self.mode = ::std::option::Option::None;
368 self.unknown_fields.clear();
369 }
370}
371
372impl ::std::fmt::Debug for TransactionOptions {
373 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
374 ::protobuf::text_format::fmt(self, f)
375 }
376}
377
378impl ::protobuf::reflect::ProtobufValue for TransactionOptions {
379 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
380 ::protobuf::reflect::ReflectValueRef::Message(self)
381 }
382}
383
384#[derive(PartialEq,Clone,Default)]
385pub struct TransactionOptions_ReadWrite {
386 pub read_lock_mode: TransactionOptions_ReadWrite_ReadLockMode,
388 pub unknown_fields: ::protobuf::UnknownFields,
390 pub cached_size: ::protobuf::CachedSize,
391}
392
393impl<'a> ::std::default::Default for &'a TransactionOptions_ReadWrite {
394 fn default() -> &'a TransactionOptions_ReadWrite {
395 <TransactionOptions_ReadWrite as ::protobuf::Message>::default_instance()
396 }
397}
398
399impl TransactionOptions_ReadWrite {
400 pub fn new() -> TransactionOptions_ReadWrite {
401 ::std::default::Default::default()
402 }
403
404 pub fn get_read_lock_mode(&self) -> TransactionOptions_ReadWrite_ReadLockMode {
408 self.read_lock_mode
409 }
410 pub fn clear_read_lock_mode(&mut self) {
411 self.read_lock_mode = TransactionOptions_ReadWrite_ReadLockMode::READ_LOCK_MODE_UNSPECIFIED;
412 }
413
414 pub fn set_read_lock_mode(&mut self, v: TransactionOptions_ReadWrite_ReadLockMode) {
416 self.read_lock_mode = v;
417 }
418}
419
420impl ::protobuf::Message for TransactionOptions_ReadWrite {
421 fn is_initialized(&self) -> bool {
422 true
423 }
424
425 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
426 while !is.eof()? {
427 let (field_number, wire_type) = is.read_tag_unpack()?;
428 match field_number {
429 1 => {
430 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.read_lock_mode, 1, &mut self.unknown_fields)?
431 },
432 _ => {
433 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
434 },
435 };
436 }
437 ::std::result::Result::Ok(())
438 }
439
440 #[allow(unused_variables)]
442 fn compute_size(&self) -> u32 {
443 let mut my_size = 0;
444 if self.read_lock_mode != TransactionOptions_ReadWrite_ReadLockMode::READ_LOCK_MODE_UNSPECIFIED {
445 my_size += ::protobuf::rt::enum_size(1, self.read_lock_mode);
446 }
447 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
448 self.cached_size.set(my_size);
449 my_size
450 }
451
452 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
453 if self.read_lock_mode != TransactionOptions_ReadWrite_ReadLockMode::READ_LOCK_MODE_UNSPECIFIED {
454 os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.read_lock_mode))?;
455 }
456 os.write_unknown_fields(self.get_unknown_fields())?;
457 ::std::result::Result::Ok(())
458 }
459
460 fn get_cached_size(&self) -> u32 {
461 self.cached_size.get()
462 }
463
464 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
465 &self.unknown_fields
466 }
467
468 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
469 &mut self.unknown_fields
470 }
471
472 fn as_any(&self) -> &dyn (::std::any::Any) {
473 self as &dyn (::std::any::Any)
474 }
475 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
476 self as &mut dyn (::std::any::Any)
477 }
478 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
479 self
480 }
481
482 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
483 Self::descriptor_static()
484 }
485
486 fn new() -> TransactionOptions_ReadWrite {
487 TransactionOptions_ReadWrite::new()
488 }
489
490 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
491 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
492 descriptor.get(|| {
493 let mut fields = ::std::vec::Vec::new();
494 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<TransactionOptions_ReadWrite_ReadLockMode>>(
495 "read_lock_mode",
496 |m: &TransactionOptions_ReadWrite| { &m.read_lock_mode },
497 |m: &mut TransactionOptions_ReadWrite| { &mut m.read_lock_mode },
498 ));
499 ::protobuf::reflect::MessageDescriptor::new_pb_name::<TransactionOptions_ReadWrite>(
500 "TransactionOptions.ReadWrite",
501 fields,
502 file_descriptor_proto()
503 )
504 })
505 }
506
507 fn default_instance() -> &'static TransactionOptions_ReadWrite {
508 static instance: ::protobuf::rt::LazyV2<TransactionOptions_ReadWrite> = ::protobuf::rt::LazyV2::INIT;
509 instance.get(TransactionOptions_ReadWrite::new)
510 }
511}
512
513impl ::protobuf::Clear for TransactionOptions_ReadWrite {
514 fn clear(&mut self) {
515 self.read_lock_mode = TransactionOptions_ReadWrite_ReadLockMode::READ_LOCK_MODE_UNSPECIFIED;
516 self.unknown_fields.clear();
517 }
518}
519
520impl ::std::fmt::Debug for TransactionOptions_ReadWrite {
521 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
522 ::protobuf::text_format::fmt(self, f)
523 }
524}
525
526impl ::protobuf::reflect::ProtobufValue for TransactionOptions_ReadWrite {
527 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
528 ::protobuf::reflect::ReflectValueRef::Message(self)
529 }
530}
531
532#[derive(Clone,PartialEq,Eq,Debug,Hash)]
533pub enum TransactionOptions_ReadWrite_ReadLockMode {
534 READ_LOCK_MODE_UNSPECIFIED = 0,
535 PESSIMISTIC = 1,
536 OPTIMISTIC = 2,
537}
538
539impl ::protobuf::ProtobufEnum for TransactionOptions_ReadWrite_ReadLockMode {
540 fn value(&self) -> i32 {
541 *self as i32
542 }
543
544 fn from_i32(value: i32) -> ::std::option::Option<TransactionOptions_ReadWrite_ReadLockMode> {
545 match value {
546 0 => ::std::option::Option::Some(TransactionOptions_ReadWrite_ReadLockMode::READ_LOCK_MODE_UNSPECIFIED),
547 1 => ::std::option::Option::Some(TransactionOptions_ReadWrite_ReadLockMode::PESSIMISTIC),
548 2 => ::std::option::Option::Some(TransactionOptions_ReadWrite_ReadLockMode::OPTIMISTIC),
549 _ => ::std::option::Option::None
550 }
551 }
552
553 fn values() -> &'static [Self] {
554 static values: &'static [TransactionOptions_ReadWrite_ReadLockMode] = &[
555 TransactionOptions_ReadWrite_ReadLockMode::READ_LOCK_MODE_UNSPECIFIED,
556 TransactionOptions_ReadWrite_ReadLockMode::PESSIMISTIC,
557 TransactionOptions_ReadWrite_ReadLockMode::OPTIMISTIC,
558 ];
559 values
560 }
561
562 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
563 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
564 descriptor.get(|| {
565 ::protobuf::reflect::EnumDescriptor::new_pb_name::<TransactionOptions_ReadWrite_ReadLockMode>("TransactionOptions.ReadWrite.ReadLockMode", file_descriptor_proto())
566 })
567 }
568}
569
570impl ::std::marker::Copy for TransactionOptions_ReadWrite_ReadLockMode {
571}
572
573impl ::std::default::Default for TransactionOptions_ReadWrite_ReadLockMode {
574 fn default() -> Self {
575 TransactionOptions_ReadWrite_ReadLockMode::READ_LOCK_MODE_UNSPECIFIED
576 }
577}
578
579impl ::protobuf::reflect::ProtobufValue for TransactionOptions_ReadWrite_ReadLockMode {
580 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
581 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
582 }
583}
584
585#[derive(PartialEq,Clone,Default)]
586pub struct TransactionOptions_PartitionedDml {
587 pub unknown_fields: ::protobuf::UnknownFields,
589 pub cached_size: ::protobuf::CachedSize,
590}
591
592impl<'a> ::std::default::Default for &'a TransactionOptions_PartitionedDml {
593 fn default() -> &'a TransactionOptions_PartitionedDml {
594 <TransactionOptions_PartitionedDml as ::protobuf::Message>::default_instance()
595 }
596}
597
598impl TransactionOptions_PartitionedDml {
599 pub fn new() -> TransactionOptions_PartitionedDml {
600 ::std::default::Default::default()
601 }
602}
603
604impl ::protobuf::Message for TransactionOptions_PartitionedDml {
605 fn is_initialized(&self) -> bool {
606 true
607 }
608
609 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
610 while !is.eof()? {
611 let (field_number, wire_type) = is.read_tag_unpack()?;
612 match field_number {
613 _ => {
614 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
615 },
616 };
617 }
618 ::std::result::Result::Ok(())
619 }
620
621 #[allow(unused_variables)]
623 fn compute_size(&self) -> u32 {
624 let mut my_size = 0;
625 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
626 self.cached_size.set(my_size);
627 my_size
628 }
629
630 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
631 os.write_unknown_fields(self.get_unknown_fields())?;
632 ::std::result::Result::Ok(())
633 }
634
635 fn get_cached_size(&self) -> u32 {
636 self.cached_size.get()
637 }
638
639 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
640 &self.unknown_fields
641 }
642
643 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
644 &mut self.unknown_fields
645 }
646
647 fn as_any(&self) -> &dyn (::std::any::Any) {
648 self as &dyn (::std::any::Any)
649 }
650 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
651 self as &mut dyn (::std::any::Any)
652 }
653 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
654 self
655 }
656
657 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
658 Self::descriptor_static()
659 }
660
661 fn new() -> TransactionOptions_PartitionedDml {
662 TransactionOptions_PartitionedDml::new()
663 }
664
665 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
666 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
667 descriptor.get(|| {
668 let fields = ::std::vec::Vec::new();
669 ::protobuf::reflect::MessageDescriptor::new_pb_name::<TransactionOptions_PartitionedDml>(
670 "TransactionOptions.PartitionedDml",
671 fields,
672 file_descriptor_proto()
673 )
674 })
675 }
676
677 fn default_instance() -> &'static TransactionOptions_PartitionedDml {
678 static instance: ::protobuf::rt::LazyV2<TransactionOptions_PartitionedDml> = ::protobuf::rt::LazyV2::INIT;
679 instance.get(TransactionOptions_PartitionedDml::new)
680 }
681}
682
683impl ::protobuf::Clear for TransactionOptions_PartitionedDml {
684 fn clear(&mut self) {
685 self.unknown_fields.clear();
686 }
687}
688
689impl ::std::fmt::Debug for TransactionOptions_PartitionedDml {
690 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
691 ::protobuf::text_format::fmt(self, f)
692 }
693}
694
695impl ::protobuf::reflect::ProtobufValue for TransactionOptions_PartitionedDml {
696 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
697 ::protobuf::reflect::ReflectValueRef::Message(self)
698 }
699}
700
701#[derive(PartialEq,Clone,Default)]
702pub struct TransactionOptions_ReadOnly {
703 pub return_read_timestamp: bool,
705 pub timestamp_bound: ::std::option::Option<TransactionOptions_ReadOnly_oneof_timestamp_bound>,
707 pub unknown_fields: ::protobuf::UnknownFields,
709 pub cached_size: ::protobuf::CachedSize,
710}
711
712impl<'a> ::std::default::Default for &'a TransactionOptions_ReadOnly {
713 fn default() -> &'a TransactionOptions_ReadOnly {
714 <TransactionOptions_ReadOnly as ::protobuf::Message>::default_instance()
715 }
716}
717
718#[derive(Clone,PartialEq,Debug)]
719pub enum TransactionOptions_ReadOnly_oneof_timestamp_bound {
720 strong(bool),
721 min_read_timestamp(::protobuf::well_known_types::Timestamp),
722 max_staleness(::protobuf::well_known_types::Duration),
723 read_timestamp(::protobuf::well_known_types::Timestamp),
724 exact_staleness(::protobuf::well_known_types::Duration),
725}
726
727impl TransactionOptions_ReadOnly {
728 pub fn new() -> TransactionOptions_ReadOnly {
729 ::std::default::Default::default()
730 }
731
732 pub fn get_strong(&self) -> bool {
736 match self.timestamp_bound {
737 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(v)) => v,
738 _ => false,
739 }
740 }
741 pub fn clear_strong(&mut self) {
742 self.timestamp_bound = ::std::option::Option::None;
743 }
744
745 pub fn has_strong(&self) -> bool {
746 match self.timestamp_bound {
747 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(..)) => true,
748 _ => false,
749 }
750 }
751
752 pub fn set_strong(&mut self, v: bool) {
754 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(v))
755 }
756
757 pub fn get_min_read_timestamp(&self) -> &::protobuf::well_known_types::Timestamp {
761 match self.timestamp_bound {
762 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref v)) => v,
763 _ => <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance(),
764 }
765 }
766 pub fn clear_min_read_timestamp(&mut self) {
767 self.timestamp_bound = ::std::option::Option::None;
768 }
769
770 pub fn has_min_read_timestamp(&self) -> bool {
771 match self.timestamp_bound {
772 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(..)) => true,
773 _ => false,
774 }
775 }
776
777 pub fn set_min_read_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) {
779 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(v))
780 }
781
782 pub fn mut_min_read_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
784 if let ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(_)) = self.timestamp_bound {
785 } else {
786 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(::protobuf::well_known_types::Timestamp::new()));
787 }
788 match self.timestamp_bound {
789 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref mut v)) => v,
790 _ => panic!(),
791 }
792 }
793
794 pub fn take_min_read_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp {
796 if self.has_min_read_timestamp() {
797 match self.timestamp_bound.take() {
798 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(v)) => v,
799 _ => panic!(),
800 }
801 } else {
802 ::protobuf::well_known_types::Timestamp::new()
803 }
804 }
805
806 pub fn get_max_staleness(&self) -> &::protobuf::well_known_types::Duration {
810 match self.timestamp_bound {
811 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref v)) => v,
812 _ => <::protobuf::well_known_types::Duration as ::protobuf::Message>::default_instance(),
813 }
814 }
815 pub fn clear_max_staleness(&mut self) {
816 self.timestamp_bound = ::std::option::Option::None;
817 }
818
819 pub fn has_max_staleness(&self) -> bool {
820 match self.timestamp_bound {
821 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(..)) => true,
822 _ => false,
823 }
824 }
825
826 pub fn set_max_staleness(&mut self, v: ::protobuf::well_known_types::Duration) {
828 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(v))
829 }
830
831 pub fn mut_max_staleness(&mut self) -> &mut ::protobuf::well_known_types::Duration {
833 if let ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(_)) = self.timestamp_bound {
834 } else {
835 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(::protobuf::well_known_types::Duration::new()));
836 }
837 match self.timestamp_bound {
838 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref mut v)) => v,
839 _ => panic!(),
840 }
841 }
842
843 pub fn take_max_staleness(&mut self) -> ::protobuf::well_known_types::Duration {
845 if self.has_max_staleness() {
846 match self.timestamp_bound.take() {
847 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(v)) => v,
848 _ => panic!(),
849 }
850 } else {
851 ::protobuf::well_known_types::Duration::new()
852 }
853 }
854
855 pub fn get_read_timestamp(&self) -> &::protobuf::well_known_types::Timestamp {
859 match self.timestamp_bound {
860 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref v)) => v,
861 _ => <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance(),
862 }
863 }
864 pub fn clear_read_timestamp(&mut self) {
865 self.timestamp_bound = ::std::option::Option::None;
866 }
867
868 pub fn has_read_timestamp(&self) -> bool {
869 match self.timestamp_bound {
870 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(..)) => true,
871 _ => false,
872 }
873 }
874
875 pub fn set_read_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) {
877 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(v))
878 }
879
880 pub fn mut_read_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
882 if let ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(_)) = self.timestamp_bound {
883 } else {
884 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(::protobuf::well_known_types::Timestamp::new()));
885 }
886 match self.timestamp_bound {
887 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref mut v)) => v,
888 _ => panic!(),
889 }
890 }
891
892 pub fn take_read_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp {
894 if self.has_read_timestamp() {
895 match self.timestamp_bound.take() {
896 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(v)) => v,
897 _ => panic!(),
898 }
899 } else {
900 ::protobuf::well_known_types::Timestamp::new()
901 }
902 }
903
904 pub fn get_exact_staleness(&self) -> &::protobuf::well_known_types::Duration {
908 match self.timestamp_bound {
909 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref v)) => v,
910 _ => <::protobuf::well_known_types::Duration as ::protobuf::Message>::default_instance(),
911 }
912 }
913 pub fn clear_exact_staleness(&mut self) {
914 self.timestamp_bound = ::std::option::Option::None;
915 }
916
917 pub fn has_exact_staleness(&self) -> bool {
918 match self.timestamp_bound {
919 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(..)) => true,
920 _ => false,
921 }
922 }
923
924 pub fn set_exact_staleness(&mut self, v: ::protobuf::well_known_types::Duration) {
926 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(v))
927 }
928
929 pub fn mut_exact_staleness(&mut self) -> &mut ::protobuf::well_known_types::Duration {
931 if let ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(_)) = self.timestamp_bound {
932 } else {
933 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(::protobuf::well_known_types::Duration::new()));
934 }
935 match self.timestamp_bound {
936 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref mut v)) => v,
937 _ => panic!(),
938 }
939 }
940
941 pub fn take_exact_staleness(&mut self) -> ::protobuf::well_known_types::Duration {
943 if self.has_exact_staleness() {
944 match self.timestamp_bound.take() {
945 ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(v)) => v,
946 _ => panic!(),
947 }
948 } else {
949 ::protobuf::well_known_types::Duration::new()
950 }
951 }
952
953 pub fn get_return_read_timestamp(&self) -> bool {
957 self.return_read_timestamp
958 }
959 pub fn clear_return_read_timestamp(&mut self) {
960 self.return_read_timestamp = false;
961 }
962
963 pub fn set_return_read_timestamp(&mut self, v: bool) {
965 self.return_read_timestamp = v;
966 }
967}
968
969impl ::protobuf::Message for TransactionOptions_ReadOnly {
970 fn is_initialized(&self) -> bool {
971 if let Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref v)) = self.timestamp_bound {
972 if !v.is_initialized() {
973 return false;
974 }
975 }
976 if let Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref v)) = self.timestamp_bound {
977 if !v.is_initialized() {
978 return false;
979 }
980 }
981 if let Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref v)) = self.timestamp_bound {
982 if !v.is_initialized() {
983 return false;
984 }
985 }
986 if let Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref v)) = self.timestamp_bound {
987 if !v.is_initialized() {
988 return false;
989 }
990 }
991 true
992 }
993
994 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
995 while !is.eof()? {
996 let (field_number, wire_type) = is.read_tag_unpack()?;
997 match field_number {
998 1 => {
999 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1000 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1001 }
1002 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(is.read_bool()?));
1003 },
1004 2 => {
1005 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
1006 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1007 }
1008 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(is.read_message()?));
1009 },
1010 3 => {
1011 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
1012 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1013 }
1014 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(is.read_message()?));
1015 },
1016 4 => {
1017 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
1018 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1019 }
1020 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(is.read_message()?));
1021 },
1022 5 => {
1023 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
1024 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1025 }
1026 self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(is.read_message()?));
1027 },
1028 6 => {
1029 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1030 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1031 }
1032 let tmp = is.read_bool()?;
1033 self.return_read_timestamp = tmp;
1034 },
1035 _ => {
1036 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1037 },
1038 };
1039 }
1040 ::std::result::Result::Ok(())
1041 }
1042
1043 #[allow(unused_variables)]
1045 fn compute_size(&self) -> u32 {
1046 let mut my_size = 0;
1047 if self.return_read_timestamp != false {
1048 my_size += 2;
1049 }
1050 if let ::std::option::Option::Some(ref v) = self.timestamp_bound {
1051 match v {
1052 &TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(v) => {
1053 my_size += 2;
1054 },
1055 &TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref v) => {
1056 let len = v.compute_size();
1057 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1058 },
1059 &TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref v) => {
1060 let len = v.compute_size();
1061 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1062 },
1063 &TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref v) => {
1064 let len = v.compute_size();
1065 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1066 },
1067 &TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref v) => {
1068 let len = v.compute_size();
1069 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1070 },
1071 };
1072 }
1073 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1074 self.cached_size.set(my_size);
1075 my_size
1076 }
1077
1078 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1079 if self.return_read_timestamp != false {
1080 os.write_bool(6, self.return_read_timestamp)?;
1081 }
1082 if let ::std::option::Option::Some(ref v) = self.timestamp_bound {
1083 match v {
1084 &TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(v) => {
1085 os.write_bool(1, v)?;
1086 },
1087 &TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref v) => {
1088 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1089 os.write_raw_varint32(v.get_cached_size())?;
1090 v.write_to_with_cached_sizes(os)?;
1091 },
1092 &TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref v) => {
1093 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1094 os.write_raw_varint32(v.get_cached_size())?;
1095 v.write_to_with_cached_sizes(os)?;
1096 },
1097 &TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref v) => {
1098 os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1099 os.write_raw_varint32(v.get_cached_size())?;
1100 v.write_to_with_cached_sizes(os)?;
1101 },
1102 &TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref v) => {
1103 os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1104 os.write_raw_varint32(v.get_cached_size())?;
1105 v.write_to_with_cached_sizes(os)?;
1106 },
1107 };
1108 }
1109 os.write_unknown_fields(self.get_unknown_fields())?;
1110 ::std::result::Result::Ok(())
1111 }
1112
1113 fn get_cached_size(&self) -> u32 {
1114 self.cached_size.get()
1115 }
1116
1117 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1118 &self.unknown_fields
1119 }
1120
1121 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1122 &mut self.unknown_fields
1123 }
1124
1125 fn as_any(&self) -> &dyn (::std::any::Any) {
1126 self as &dyn (::std::any::Any)
1127 }
1128 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1129 self as &mut dyn (::std::any::Any)
1130 }
1131 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1132 self
1133 }
1134
1135 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1136 Self::descriptor_static()
1137 }
1138
1139 fn new() -> TransactionOptions_ReadOnly {
1140 TransactionOptions_ReadOnly::new()
1141 }
1142
1143 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1144 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1145 descriptor.get(|| {
1146 let mut fields = ::std::vec::Vec::new();
1147 fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
1148 "strong",
1149 TransactionOptions_ReadOnly::has_strong,
1150 TransactionOptions_ReadOnly::get_strong,
1151 ));
1152 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Timestamp>(
1153 "min_read_timestamp",
1154 TransactionOptions_ReadOnly::has_min_read_timestamp,
1155 TransactionOptions_ReadOnly::get_min_read_timestamp,
1156 ));
1157 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Duration>(
1158 "max_staleness",
1159 TransactionOptions_ReadOnly::has_max_staleness,
1160 TransactionOptions_ReadOnly::get_max_staleness,
1161 ));
1162 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Timestamp>(
1163 "read_timestamp",
1164 TransactionOptions_ReadOnly::has_read_timestamp,
1165 TransactionOptions_ReadOnly::get_read_timestamp,
1166 ));
1167 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Duration>(
1168 "exact_staleness",
1169 TransactionOptions_ReadOnly::has_exact_staleness,
1170 TransactionOptions_ReadOnly::get_exact_staleness,
1171 ));
1172 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1173 "return_read_timestamp",
1174 |m: &TransactionOptions_ReadOnly| { &m.return_read_timestamp },
1175 |m: &mut TransactionOptions_ReadOnly| { &mut m.return_read_timestamp },
1176 ));
1177 ::protobuf::reflect::MessageDescriptor::new_pb_name::<TransactionOptions_ReadOnly>(
1178 "TransactionOptions.ReadOnly",
1179 fields,
1180 file_descriptor_proto()
1181 )
1182 })
1183 }
1184
1185 fn default_instance() -> &'static TransactionOptions_ReadOnly {
1186 static instance: ::protobuf::rt::LazyV2<TransactionOptions_ReadOnly> = ::protobuf::rt::LazyV2::INIT;
1187 instance.get(TransactionOptions_ReadOnly::new)
1188 }
1189}
1190
1191impl ::protobuf::Clear for TransactionOptions_ReadOnly {
1192 fn clear(&mut self) {
1193 self.timestamp_bound = ::std::option::Option::None;
1194 self.timestamp_bound = ::std::option::Option::None;
1195 self.timestamp_bound = ::std::option::Option::None;
1196 self.timestamp_bound = ::std::option::Option::None;
1197 self.timestamp_bound = ::std::option::Option::None;
1198 self.return_read_timestamp = false;
1199 self.unknown_fields.clear();
1200 }
1201}
1202
1203impl ::std::fmt::Debug for TransactionOptions_ReadOnly {
1204 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1205 ::protobuf::text_format::fmt(self, f)
1206 }
1207}
1208
1209impl ::protobuf::reflect::ProtobufValue for TransactionOptions_ReadOnly {
1210 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1211 ::protobuf::reflect::ReflectValueRef::Message(self)
1212 }
1213}
1214
1215#[derive(PartialEq,Clone,Default)]
1216pub struct Transaction {
1217 pub id: ::std::vec::Vec<u8>,
1219 pub read_timestamp: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
1220 pub unknown_fields: ::protobuf::UnknownFields,
1222 pub cached_size: ::protobuf::CachedSize,
1223}
1224
1225impl<'a> ::std::default::Default for &'a Transaction {
1226 fn default() -> &'a Transaction {
1227 <Transaction as ::protobuf::Message>::default_instance()
1228 }
1229}
1230
1231impl Transaction {
1232 pub fn new() -> Transaction {
1233 ::std::default::Default::default()
1234 }
1235
1236 pub fn get_id(&self) -> &[u8] {
1240 &self.id
1241 }
1242 pub fn clear_id(&mut self) {
1243 self.id.clear();
1244 }
1245
1246 pub fn set_id(&mut self, v: ::std::vec::Vec<u8>) {
1248 self.id = v;
1249 }
1250
1251 pub fn mut_id(&mut self) -> &mut ::std::vec::Vec<u8> {
1254 &mut self.id
1255 }
1256
1257 pub fn take_id(&mut self) -> ::std::vec::Vec<u8> {
1259 ::std::mem::replace(&mut self.id, ::std::vec::Vec::new())
1260 }
1261
1262 pub fn get_read_timestamp(&self) -> &::protobuf::well_known_types::Timestamp {
1266 self.read_timestamp.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
1267 }
1268 pub fn clear_read_timestamp(&mut self) {
1269 self.read_timestamp.clear();
1270 }
1271
1272 pub fn has_read_timestamp(&self) -> bool {
1273 self.read_timestamp.is_some()
1274 }
1275
1276 pub fn set_read_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) {
1278 self.read_timestamp = ::protobuf::SingularPtrField::some(v);
1279 }
1280
1281 pub fn mut_read_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
1284 if self.read_timestamp.is_none() {
1285 self.read_timestamp.set_default();
1286 }
1287 self.read_timestamp.as_mut().unwrap()
1288 }
1289
1290 pub fn take_read_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp {
1292 self.read_timestamp.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
1293 }
1294}
1295
1296impl ::protobuf::Message for Transaction {
1297 fn is_initialized(&self) -> bool {
1298 for v in &self.read_timestamp {
1299 if !v.is_initialized() {
1300 return false;
1301 }
1302 };
1303 true
1304 }
1305
1306 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1307 while !is.eof()? {
1308 let (field_number, wire_type) = is.read_tag_unpack()?;
1309 match field_number {
1310 1 => {
1311 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.id)?;
1312 },
1313 2 => {
1314 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.read_timestamp)?;
1315 },
1316 _ => {
1317 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1318 },
1319 };
1320 }
1321 ::std::result::Result::Ok(())
1322 }
1323
1324 #[allow(unused_variables)]
1326 fn compute_size(&self) -> u32 {
1327 let mut my_size = 0;
1328 if !self.id.is_empty() {
1329 my_size += ::protobuf::rt::bytes_size(1, &self.id);
1330 }
1331 if let Some(ref v) = self.read_timestamp.as_ref() {
1332 let len = v.compute_size();
1333 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1334 }
1335 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1336 self.cached_size.set(my_size);
1337 my_size
1338 }
1339
1340 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1341 if !self.id.is_empty() {
1342 os.write_bytes(1, &self.id)?;
1343 }
1344 if let Some(ref v) = self.read_timestamp.as_ref() {
1345 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1346 os.write_raw_varint32(v.get_cached_size())?;
1347 v.write_to_with_cached_sizes(os)?;
1348 }
1349 os.write_unknown_fields(self.get_unknown_fields())?;
1350 ::std::result::Result::Ok(())
1351 }
1352
1353 fn get_cached_size(&self) -> u32 {
1354 self.cached_size.get()
1355 }
1356
1357 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1358 &self.unknown_fields
1359 }
1360
1361 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1362 &mut self.unknown_fields
1363 }
1364
1365 fn as_any(&self) -> &dyn (::std::any::Any) {
1366 self as &dyn (::std::any::Any)
1367 }
1368 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1369 self as &mut dyn (::std::any::Any)
1370 }
1371 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1372 self
1373 }
1374
1375 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1376 Self::descriptor_static()
1377 }
1378
1379 fn new() -> Transaction {
1380 Transaction::new()
1381 }
1382
1383 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1384 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1385 descriptor.get(|| {
1386 let mut fields = ::std::vec::Vec::new();
1387 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
1388 "id",
1389 |m: &Transaction| { &m.id },
1390 |m: &mut Transaction| { &mut m.id },
1391 ));
1392 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
1393 "read_timestamp",
1394 |m: &Transaction| { &m.read_timestamp },
1395 |m: &mut Transaction| { &mut m.read_timestamp },
1396 ));
1397 ::protobuf::reflect::MessageDescriptor::new_pb_name::<Transaction>(
1398 "Transaction",
1399 fields,
1400 file_descriptor_proto()
1401 )
1402 })
1403 }
1404
1405 fn default_instance() -> &'static Transaction {
1406 static instance: ::protobuf::rt::LazyV2<Transaction> = ::protobuf::rt::LazyV2::INIT;
1407 instance.get(Transaction::new)
1408 }
1409}
1410
1411impl ::protobuf::Clear for Transaction {
1412 fn clear(&mut self) {
1413 self.id.clear();
1414 self.read_timestamp.clear();
1415 self.unknown_fields.clear();
1416 }
1417}
1418
1419impl ::std::fmt::Debug for Transaction {
1420 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1421 ::protobuf::text_format::fmt(self, f)
1422 }
1423}
1424
1425impl ::protobuf::reflect::ProtobufValue for Transaction {
1426 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1427 ::protobuf::reflect::ReflectValueRef::Message(self)
1428 }
1429}
1430
1431#[derive(PartialEq,Clone,Default)]
1432pub struct TransactionSelector {
1433 pub selector: ::std::option::Option<TransactionSelector_oneof_selector>,
1435 pub unknown_fields: ::protobuf::UnknownFields,
1437 pub cached_size: ::protobuf::CachedSize,
1438}
1439
1440impl<'a> ::std::default::Default for &'a TransactionSelector {
1441 fn default() -> &'a TransactionSelector {
1442 <TransactionSelector as ::protobuf::Message>::default_instance()
1443 }
1444}
1445
1446#[derive(Clone,PartialEq,Debug)]
1447pub enum TransactionSelector_oneof_selector {
1448 single_use(TransactionOptions),
1449 id(::std::vec::Vec<u8>),
1450 begin(TransactionOptions),
1451}
1452
1453impl TransactionSelector {
1454 pub fn new() -> TransactionSelector {
1455 ::std::default::Default::default()
1456 }
1457
1458 pub fn get_single_use(&self) -> &TransactionOptions {
1462 match self.selector {
1463 ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(ref v)) => v,
1464 _ => <TransactionOptions as ::protobuf::Message>::default_instance(),
1465 }
1466 }
1467 pub fn clear_single_use(&mut self) {
1468 self.selector = ::std::option::Option::None;
1469 }
1470
1471 pub fn has_single_use(&self) -> bool {
1472 match self.selector {
1473 ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(..)) => true,
1474 _ => false,
1475 }
1476 }
1477
1478 pub fn set_single_use(&mut self, v: TransactionOptions) {
1480 self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(v))
1481 }
1482
1483 pub fn mut_single_use(&mut self) -> &mut TransactionOptions {
1485 if let ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(_)) = self.selector {
1486 } else {
1487 self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(TransactionOptions::new()));
1488 }
1489 match self.selector {
1490 ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(ref mut v)) => v,
1491 _ => panic!(),
1492 }
1493 }
1494
1495 pub fn take_single_use(&mut self) -> TransactionOptions {
1497 if self.has_single_use() {
1498 match self.selector.take() {
1499 ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(v)) => v,
1500 _ => panic!(),
1501 }
1502 } else {
1503 TransactionOptions::new()
1504 }
1505 }
1506
1507 pub fn get_id(&self) -> &[u8] {
1511 match self.selector {
1512 ::std::option::Option::Some(TransactionSelector_oneof_selector::id(ref v)) => v,
1513 _ => &[],
1514 }
1515 }
1516 pub fn clear_id(&mut self) {
1517 self.selector = ::std::option::Option::None;
1518 }
1519
1520 pub fn has_id(&self) -> bool {
1521 match self.selector {
1522 ::std::option::Option::Some(TransactionSelector_oneof_selector::id(..)) => true,
1523 _ => false,
1524 }
1525 }
1526
1527 pub fn set_id(&mut self, v: ::std::vec::Vec<u8>) {
1529 self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::id(v))
1530 }
1531
1532 pub fn mut_id(&mut self) -> &mut ::std::vec::Vec<u8> {
1534 if let ::std::option::Option::Some(TransactionSelector_oneof_selector::id(_)) = self.selector {
1535 } else {
1536 self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::id(::std::vec::Vec::new()));
1537 }
1538 match self.selector {
1539 ::std::option::Option::Some(TransactionSelector_oneof_selector::id(ref mut v)) => v,
1540 _ => panic!(),
1541 }
1542 }
1543
1544 pub fn take_id(&mut self) -> ::std::vec::Vec<u8> {
1546 if self.has_id() {
1547 match self.selector.take() {
1548 ::std::option::Option::Some(TransactionSelector_oneof_selector::id(v)) => v,
1549 _ => panic!(),
1550 }
1551 } else {
1552 ::std::vec::Vec::new()
1553 }
1554 }
1555
1556 pub fn get_begin(&self) -> &TransactionOptions {
1560 match self.selector {
1561 ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(ref v)) => v,
1562 _ => <TransactionOptions as ::protobuf::Message>::default_instance(),
1563 }
1564 }
1565 pub fn clear_begin(&mut self) {
1566 self.selector = ::std::option::Option::None;
1567 }
1568
1569 pub fn has_begin(&self) -> bool {
1570 match self.selector {
1571 ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(..)) => true,
1572 _ => false,
1573 }
1574 }
1575
1576 pub fn set_begin(&mut self, v: TransactionOptions) {
1578 self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(v))
1579 }
1580
1581 pub fn mut_begin(&mut self) -> &mut TransactionOptions {
1583 if let ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(_)) = self.selector {
1584 } else {
1585 self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(TransactionOptions::new()));
1586 }
1587 match self.selector {
1588 ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(ref mut v)) => v,
1589 _ => panic!(),
1590 }
1591 }
1592
1593 pub fn take_begin(&mut self) -> TransactionOptions {
1595 if self.has_begin() {
1596 match self.selector.take() {
1597 ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(v)) => v,
1598 _ => panic!(),
1599 }
1600 } else {
1601 TransactionOptions::new()
1602 }
1603 }
1604}
1605
1606impl ::protobuf::Message for TransactionSelector {
1607 fn is_initialized(&self) -> bool {
1608 if let Some(TransactionSelector_oneof_selector::single_use(ref v)) = self.selector {
1609 if !v.is_initialized() {
1610 return false;
1611 }
1612 }
1613 if let Some(TransactionSelector_oneof_selector::begin(ref v)) = self.selector {
1614 if !v.is_initialized() {
1615 return false;
1616 }
1617 }
1618 true
1619 }
1620
1621 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1622 while !is.eof()? {
1623 let (field_number, wire_type) = is.read_tag_unpack()?;
1624 match field_number {
1625 1 => {
1626 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
1627 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1628 }
1629 self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(is.read_message()?));
1630 },
1631 2 => {
1632 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
1633 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1634 }
1635 self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::id(is.read_bytes()?));
1636 },
1637 3 => {
1638 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
1639 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1640 }
1641 self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(is.read_message()?));
1642 },
1643 _ => {
1644 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1645 },
1646 };
1647 }
1648 ::std::result::Result::Ok(())
1649 }
1650
1651 #[allow(unused_variables)]
1653 fn compute_size(&self) -> u32 {
1654 let mut my_size = 0;
1655 if let ::std::option::Option::Some(ref v) = self.selector {
1656 match v {
1657 &TransactionSelector_oneof_selector::single_use(ref v) => {
1658 let len = v.compute_size();
1659 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1660 },
1661 &TransactionSelector_oneof_selector::id(ref v) => {
1662 my_size += ::protobuf::rt::bytes_size(2, &v);
1663 },
1664 &TransactionSelector_oneof_selector::begin(ref v) => {
1665 let len = v.compute_size();
1666 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1667 },
1668 };
1669 }
1670 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1671 self.cached_size.set(my_size);
1672 my_size
1673 }
1674
1675 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1676 if let ::std::option::Option::Some(ref v) = self.selector {
1677 match v {
1678 &TransactionSelector_oneof_selector::single_use(ref v) => {
1679 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1680 os.write_raw_varint32(v.get_cached_size())?;
1681 v.write_to_with_cached_sizes(os)?;
1682 },
1683 &TransactionSelector_oneof_selector::id(ref v) => {
1684 os.write_bytes(2, v)?;
1685 },
1686 &TransactionSelector_oneof_selector::begin(ref v) => {
1687 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1688 os.write_raw_varint32(v.get_cached_size())?;
1689 v.write_to_with_cached_sizes(os)?;
1690 },
1691 };
1692 }
1693 os.write_unknown_fields(self.get_unknown_fields())?;
1694 ::std::result::Result::Ok(())
1695 }
1696
1697 fn get_cached_size(&self) -> u32 {
1698 self.cached_size.get()
1699 }
1700
1701 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1702 &self.unknown_fields
1703 }
1704
1705 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1706 &mut self.unknown_fields
1707 }
1708
1709 fn as_any(&self) -> &dyn (::std::any::Any) {
1710 self as &dyn (::std::any::Any)
1711 }
1712 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1713 self as &mut dyn (::std::any::Any)
1714 }
1715 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1716 self
1717 }
1718
1719 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1720 Self::descriptor_static()
1721 }
1722
1723 fn new() -> TransactionSelector {
1724 TransactionSelector::new()
1725 }
1726
1727 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1728 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1729 descriptor.get(|| {
1730 let mut fields = ::std::vec::Vec::new();
1731 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions>(
1732 "single_use",
1733 TransactionSelector::has_single_use,
1734 TransactionSelector::get_single_use,
1735 ));
1736 fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
1737 "id",
1738 TransactionSelector::has_id,
1739 TransactionSelector::get_id,
1740 ));
1741 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions>(
1742 "begin",
1743 TransactionSelector::has_begin,
1744 TransactionSelector::get_begin,
1745 ));
1746 ::protobuf::reflect::MessageDescriptor::new_pb_name::<TransactionSelector>(
1747 "TransactionSelector",
1748 fields,
1749 file_descriptor_proto()
1750 )
1751 })
1752 }
1753
1754 fn default_instance() -> &'static TransactionSelector {
1755 static instance: ::protobuf::rt::LazyV2<TransactionSelector> = ::protobuf::rt::LazyV2::INIT;
1756 instance.get(TransactionSelector::new)
1757 }
1758}
1759
1760impl ::protobuf::Clear for TransactionSelector {
1761 fn clear(&mut self) {
1762 self.selector = ::std::option::Option::None;
1763 self.selector = ::std::option::Option::None;
1764 self.selector = ::std::option::Option::None;
1765 self.unknown_fields.clear();
1766 }
1767}
1768
1769impl ::std::fmt::Debug for TransactionSelector {
1770 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1771 ::protobuf::text_format::fmt(self, f)
1772 }
1773}
1774
1775impl ::protobuf::reflect::ProtobufValue for TransactionSelector {
1776 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1777 ::protobuf::reflect::ReflectValueRef::Message(self)
1778 }
1779}
1780
1781static file_descriptor_proto_data: &'static [u8] = b"\
1782 \n#google/spanner/v1/transaction.proto\x12\x11google.spanner.v1\x1a\x1eg\
1783 oogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\
1784 \xfa\x06\n\x12TransactionOptions\x12P\n\nread_write\x18\x01\x20\x01(\x0b\
1785 2/.google.spanner.v1.TransactionOptions.ReadWriteH\0R\treadWrite\x12_\n\
1786 \x0fpartitioned_dml\x18\x03\x20\x01(\x0b24.google.spanner.v1.Transaction\
1787 Options.PartitionedDmlH\0R\x0epartitionedDml\x12M\n\tread_only\x18\x02\
1788 \x20\x01(\x0b2..google.spanner.v1.TransactionOptions.ReadOnlyH\0R\x08rea\
1789 dOnly\x1a\xc0\x01\n\tReadWrite\x12b\n\x0eread_lock_mode\x18\x01\x20\x01(\
1790 \x0e2<.google.spanner.v1.TransactionOptions.ReadWrite.ReadLockModeR\x0cr\
1791 eadLockMode\"O\n\x0cReadLockMode\x12\x1e\n\x1aREAD_LOCK_MODE_UNSPECIFIED\
1792 \x10\0\x12\x0f\n\x0bPESSIMISTIC\x10\x01\x12\x0e\n\nOPTIMISTIC\x10\x02\
1793 \x1a\x10\n\x0ePartitionedDml\x1a\x84\x03\n\x08ReadOnly\x12\x18\n\x06stro\
1794 ng\x18\x01\x20\x01(\x08H\0R\x06strong\x12J\n\x12min_read_timestamp\x18\
1795 \x02\x20\x01(\x0b2\x1a.google.protobuf.TimestampH\0R\x10minReadTimestamp\
1796 \x12@\n\rmax_staleness\x18\x03\x20\x01(\x0b2\x19.google.protobuf.Duratio\
1797 nH\0R\x0cmaxStaleness\x12C\n\x0eread_timestamp\x18\x04\x20\x01(\x0b2\x1a\
1798 .google.protobuf.TimestampH\0R\rreadTimestamp\x12D\n\x0fexact_staleness\
1799 \x18\x05\x20\x01(\x0b2\x19.google.protobuf.DurationH\0R\x0eexactStalenes\
1800 s\x122\n\x15return_read_timestamp\x18\x06\x20\x01(\x08R\x13returnReadTim\
1801 estampB\x11\n\x0ftimestamp_boundB\x06\n\x04mode\"`\n\x0bTransaction\x12\
1802 \x0e\n\x02id\x18\x01\x20\x01(\x0cR\x02id\x12A\n\x0eread_timestamp\x18\
1803 \x02\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\rreadTimestamp\"\xba\
1804 \x01\n\x13TransactionSelector\x12F\n\nsingle_use\x18\x01\x20\x01(\x0b2%.\
1805 google.spanner.v1.TransactionOptionsH\0R\tsingleUse\x12\x10\n\x02id\x18\
1806 \x02\x20\x01(\x0cH\0R\x02id\x12=\n\x05begin\x18\x03\x20\x01(\x0b2%.googl\
1807 e.spanner.v1.TransactionOptionsH\0R\x05beginB\n\n\x08selectorB\xb3\x01\n\
1808 \x15com.google.spanner.v1B\x10TransactionProtoP\x01Z5cloud.google.com/go\
1809 /spanner/apiv1/spannerpb;spannerpb\xaa\x02\x17Google.Cloud.Spanner.V1\
1810 \xca\x02\x17Google\\Cloud\\Spanner\\V1\xea\x02\x1aGoogle::Cloud::Spanner\
1811 ::V1J\xf5\xb1\x01\n\x07\x12\x05\x0e\0\x8c\x04\x01\n\xbc\x04\n\x01\x0c\
1812 \x12\x03\x0e\0\x122\xb1\x04\x20Copyright\x202022\x20Google\x20LLC\n\n\
1813 \x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20\
1814 (the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20e\
1815 xcept\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20\
1816 obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\
1817 \x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\
1818 \x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20s\
1819 oftware\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\
1820 \x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\
1821 \x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20impli\
1822 ed.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20\
1823 governing\x20permissions\x20and\n\x20limitations\x20under\x20the\x20Lice\
1824 nse.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1a\n\t\n\x02\x03\0\x12\x03\x12\0(\
1825 \n\t\n\x02\x03\x01\x12\x03\x13\0)\n\x08\n\x01\x08\x12\x03\x15\04\n\t\n\
1826 \x02\x08%\x12\x03\x15\04\n\x08\n\x01\x08\x12\x03\x16\0L\n\t\n\x02\x08\
1827 \x0b\x12\x03\x16\0L\n\x08\n\x01\x08\x12\x03\x17\0\"\n\t\n\x02\x08\n\x12\
1828 \x03\x17\0\"\n\x08\n\x01\x08\x12\x03\x18\01\n\t\n\x02\x08\x08\x12\x03\
1829 \x18\01\n\x08\n\x01\x08\x12\x03\x19\0.\n\t\n\x02\x08\x01\x12\x03\x19\0.\
1830 \n\x08\n\x01\x08\x12\x03\x1a\04\n\t\n\x02\x08)\x12\x03\x1a\04\n\x08\n\
1831 \x01\x08\x12\x03\x1b\03\n\t\n\x02\x08-\x12\x03\x1b\03\n\xcew\n\x02\x04\0\
1832 \x12\x06\xe1\x02\0\xdd\x03\x01\x1a\xbfw\x20Transactions:\n\n\x20Each\x20\
1833 session\x20can\x20have\x20at\x20most\x20one\x20active\x20transaction\x20\
1834 at\x20a\x20time\x20(note\x20that\n\x20standalone\x20reads\x20and\x20quer\
1835 ies\x20use\x20a\x20transaction\x20internally\x20and\x20do\x20count\n\x20\
1836 towards\x20the\x20one\x20transaction\x20limit).\x20After\x20the\x20activ\
1837 e\x20transaction\x20is\n\x20completed,\x20the\x20session\x20can\x20immed\
1838 iately\x20be\x20re-used\x20for\x20the\x20next\x20transaction.\n\x20It\
1839 \x20is\x20not\x20necessary\x20to\x20create\x20a\x20new\x20session\x20for\
1840 \x20each\x20transaction.\n\n\x20Transaction\x20modes:\n\n\x20Cloud\x20Sp\
1841 anner\x20supports\x20three\x20transaction\x20modes:\n\n\x20\x20\x201.\
1842 \x20Locking\x20read-write.\x20This\x20type\x20of\x20transaction\x20is\
1843 \x20the\x20only\x20way\n\x20\x20\x20\x20\x20\x20to\x20write\x20data\x20i\
1844 nto\x20Cloud\x20Spanner.\x20These\x20transactions\x20rely\x20on\n\x20\
1845 \x20\x20\x20\x20\x20pessimistic\x20locking\x20and,\x20if\x20necessary,\
1846 \x20two-phase\x20commit.\n\x20\x20\x20\x20\x20\x20Locking\x20read-write\
1847 \x20transactions\x20may\x20abort,\x20requiring\x20the\n\x20\x20\x20\x20\
1848 \x20\x20application\x20to\x20retry.\n\n\x20\x20\x202.\x20Snapshot\x20rea\
1849 d-only.\x20Snapshot\x20read-only\x20transactions\x20provide\x20guarantee\
1850 d\n\x20\x20\x20\x20\x20\x20consistency\x20across\x20several\x20reads,\
1851 \x20but\x20do\x20not\x20allow\n\x20\x20\x20\x20\x20\x20writes.\x20Snapsh\
1852 ot\x20read-only\x20transactions\x20can\x20be\x20configured\x20to\x20read\
1853 \x20at\n\x20\x20\x20\x20\x20\x20timestamps\x20in\x20the\x20past,\x20or\
1854 \x20configured\x20to\x20perform\x20a\x20strong\x20read\n\x20\x20\x20\x20\
1855 \x20\x20(where\x20Spanner\x20will\x20select\x20a\x20timestamp\x20such\
1856 \x20that\x20the\x20read\x20is\n\x20\x20\x20\x20\x20\x20guaranteed\x20to\
1857 \x20see\x20the\x20effects\x20of\x20all\x20transactions\x20that\x20have\
1858 \x20committed\n\x20\x20\x20\x20\x20\x20before\x20the\x20start\x20of\x20t\
1859 he\x20read).\x20Snapshot\x20read-only\x20transactions\x20do\x20not\n\x20\
1860 \x20\x20\x20\x20\x20need\x20to\x20be\x20committed.\n\n\x20\x20\x20\x20\
1861 \x20\x20Queries\x20on\x20change\x20streams\x20must\x20be\x20performed\
1862 \x20with\x20the\x20snapshot\x20read-only\n\x20\x20\x20\x20\x20\x20transa\
1863 ction\x20mode,\x20specifying\x20a\x20strong\x20read.\x20Please\x20see\n\
1864 \x20\x20\x20\x20\x20\x20[TransactionOptions.ReadOnly.strong][google.span\
1865 ner.v1.TransactionOptions.ReadOnly.strong]\n\x20\x20\x20\x20\x20\x20for\
1866 \x20more\x20details.\n\n\x20\x20\x203.\x20Partitioned\x20DML.\x20This\
1867 \x20type\x20of\x20transaction\x20is\x20used\x20to\x20execute\n\x20\x20\
1868 \x20\x20\x20\x20a\x20single\x20Partitioned\x20DML\x20statement.\x20Parti\
1869 tioned\x20DML\x20partitions\n\x20\x20\x20\x20\x20\x20the\x20key\x20space\
1870 \x20and\x20runs\x20the\x20DML\x20statement\x20over\x20each\x20partition\
1871 \n\x20\x20\x20\x20\x20\x20in\x20parallel\x20using\x20separate,\x20intern\
1872 al\x20transactions\x20that\x20commit\n\x20\x20\x20\x20\x20\x20independen\
1873 tly.\x20Partitioned\x20DML\x20transactions\x20do\x20not\x20need\x20to\
1874 \x20be\n\x20\x20\x20\x20\x20\x20committed.\n\n\x20For\x20transactions\
1875 \x20that\x20only\x20read,\x20snapshot\x20read-only\x20transactions\n\x20\
1876 provide\x20simpler\x20semantics\x20and\x20are\x20almost\x20always\x20fas\
1877 ter.\x20In\n\x20particular,\x20read-only\x20transactions\x20do\x20not\
1878 \x20take\x20locks,\x20so\x20they\x20do\n\x20not\x20conflict\x20with\x20r\
1879 ead-write\x20transactions.\x20As\x20a\x20consequence\x20of\x20not\n\x20t\
1880 aking\x20locks,\x20they\x20also\x20do\x20not\x20abort,\x20so\x20retry\
1881 \x20loops\x20are\x20not\x20needed.\n\n\x20Transactions\x20may\x20only\
1882 \x20read-write\x20data\x20in\x20a\x20single\x20database.\x20They\n\x20ma\
1883 y,\x20however,\x20read-write\x20data\x20in\x20different\x20tables\x20wit\
1884 hin\x20that\n\x20database.\n\n\x20Locking\x20read-write\x20transactions:\
1885 \n\n\x20Locking\x20transactions\x20may\x20be\x20used\x20to\x20atomically\
1886 \x20read-modify-write\n\x20data\x20anywhere\x20in\x20a\x20database.\x20T\
1887 his\x20type\x20of\x20transaction\x20is\x20externally\n\x20consistent.\n\
1888 \n\x20Clients\x20should\x20attempt\x20to\x20minimize\x20the\x20amount\
1889 \x20of\x20time\x20a\x20transaction\n\x20is\x20active.\x20Faster\x20trans\
1890 actions\x20commit\x20with\x20higher\x20probability\n\x20and\x20cause\x20\
1891 less\x20contention.\x20Cloud\x20Spanner\x20attempts\x20to\x20keep\x20rea\
1892 d\x20locks\n\x20active\x20as\x20long\x20as\x20the\x20transaction\x20cont\
1893 inues\x20to\x20do\x20reads,\x20and\x20the\n\x20transaction\x20has\x20not\
1894 \x20been\x20terminated\x20by\n\x20[Commit][google.spanner.v1.Spanner.Com\
1895 mit]\x20or\n\x20[Rollback][google.spanner.v1.Spanner.Rollback].\x20Long\
1896 \x20periods\x20of\n\x20inactivity\x20at\x20the\x20client\x20may\x20cause\
1897 \x20Cloud\x20Spanner\x20to\x20release\x20a\n\x20transaction's\x20locks\
1898 \x20and\x20abort\x20it.\n\n\x20Conceptually,\x20a\x20read-write\x20trans\
1899 action\x20consists\x20of\x20zero\x20or\x20more\n\x20reads\x20or\x20SQL\
1900 \x20statements\x20followed\x20by\n\x20[Commit][google.spanner.v1.Spanner\
1901 .Commit].\x20At\x20any\x20time\x20before\n\x20[Commit][google.spanner.v1\
1902 .Spanner.Commit],\x20the\x20client\x20can\x20send\x20a\n\x20[Rollback][g\
1903 oogle.spanner.v1.Spanner.Rollback]\x20request\x20to\x20abort\x20the\n\
1904 \x20transaction.\n\n\x20Semantics:\n\n\x20Cloud\x20Spanner\x20can\x20com\
1905 mit\x20the\x20transaction\x20if\x20all\x20read\x20locks\x20it\x20acquire\
1906 d\n\x20are\x20still\x20valid\x20at\x20commit\x20time,\x20and\x20it\x20is\
1907 \x20able\x20to\x20acquire\x20write\n\x20locks\x20for\x20all\x20writes.\
1908 \x20Cloud\x20Spanner\x20can\x20abort\x20the\x20transaction\x20for\x20any\
1909 \n\x20reason.\x20If\x20a\x20commit\x20attempt\x20returns\x20`ABORTED`,\
1910 \x20Cloud\x20Spanner\x20guarantees\n\x20that\x20the\x20transaction\x20ha\
1911 s\x20not\x20modified\x20any\x20user\x20data\x20in\x20Cloud\x20Spanner.\n\
1912 \n\x20Unless\x20the\x20transaction\x20commits,\x20Cloud\x20Spanner\x20ma\
1913 kes\x20no\x20guarantees\x20about\n\x20how\x20long\x20the\x20transaction'\
1914 s\x20locks\x20were\x20held\x20for.\x20It\x20is\x20an\x20error\x20to\n\
1915 \x20use\x20Cloud\x20Spanner\x20locks\x20for\x20any\x20sort\x20of\x20mutu\
1916 al\x20exclusion\x20other\x20than\n\x20between\x20Cloud\x20Spanner\x20tra\
1917 nsactions\x20themselves.\n\n\x20Retrying\x20aborted\x20transactions:\n\n\
1918 \x20When\x20a\x20transaction\x20aborts,\x20the\x20application\x20can\x20\
1919 choose\x20to\x20retry\x20the\n\x20whole\x20transaction\x20again.\x20To\
1920 \x20maximize\x20the\x20chances\x20of\x20successfully\n\x20committing\x20\
1921 the\x20retry,\x20the\x20client\x20should\x20execute\x20the\x20retry\x20i\
1922 n\x20the\n\x20same\x20session\x20as\x20the\x20original\x20attempt.\x20Th\
1923 e\x20original\x20session's\x20lock\n\x20priority\x20increases\x20with\
1924 \x20each\x20consecutive\x20abort,\x20meaning\x20that\x20each\n\x20attemp\
1925 t\x20has\x20a\x20slightly\x20better\x20chance\x20of\x20success\x20than\
1926 \x20the\x20previous.\n\n\x20Under\x20some\x20circumstances\x20(for\x20ex\
1927 ample,\x20many\x20transactions\x20attempting\x20to\n\x20modify\x20the\
1928 \x20same\x20row(s)),\x20a\x20transaction\x20can\x20abort\x20many\x20time\
1929 s\x20in\x20a\n\x20short\x20period\x20before\x20successfully\x20committin\
1930 g.\x20Thus,\x20it\x20is\x20not\x20a\x20good\n\x20idea\x20to\x20cap\x20th\
1931 e\x20number\x20of\x20retries\x20a\x20transaction\x20can\x20attempt;\n\
1932 \x20instead,\x20it\x20is\x20better\x20to\x20limit\x20the\x20total\x20amo\
1933 unt\x20of\x20time\x20spent\n\x20retrying.\n\n\x20Idle\x20transactions:\n\
1934 \n\x20A\x20transaction\x20is\x20considered\x20idle\x20if\x20it\x20has\
1935 \x20no\x20outstanding\x20reads\x20or\n\x20SQL\x20queries\x20and\x20has\
1936 \x20not\x20started\x20a\x20read\x20or\x20SQL\x20query\x20within\x20the\
1937 \x20last\x2010\n\x20seconds.\x20Idle\x20transactions\x20can\x20be\x20abo\
1938 rted\x20by\x20Cloud\x20Spanner\x20so\x20that\x20they\n\x20don't\x20hold\
1939 \x20on\x20to\x20locks\x20indefinitely.\x20If\x20an\x20idle\x20transactio\
1940 n\x20is\x20aborted,\x20the\n\x20commit\x20will\x20fail\x20with\x20error\
1941 \x20`ABORTED`.\n\n\x20If\x20this\x20behavior\x20is\x20undesirable,\x20pe\
1942 riodically\x20executing\x20a\x20simple\n\x20SQL\x20query\x20in\x20the\
1943 \x20transaction\x20(for\x20example,\x20`SELECT\x201`)\x20prevents\x20the\
1944 \n\x20transaction\x20from\x20becoming\x20idle.\n\n\x20Snapshot\x20read-o\
1945 nly\x20transactions:\n\n\x20Snapshot\x20read-only\x20transactions\x20pro\
1946 vides\x20a\x20simpler\x20method\x20than\n\x20locking\x20read-write\x20tr\
1947 ansactions\x20for\x20doing\x20several\x20consistent\n\x20reads.\x20Howev\
1948 er,\x20this\x20type\x20of\x20transaction\x20does\x20not\x20support\x20wr\
1949 ites.\n\n\x20Snapshot\x20transactions\x20do\x20not\x20take\x20locks.\x20\
1950 Instead,\x20they\x20work\x20by\n\x20choosing\x20a\x20Cloud\x20Spanner\
1951 \x20timestamp,\x20then\x20executing\x20all\x20reads\x20at\x20that\n\x20t\
1952 imestamp.\x20Since\x20they\x20do\x20not\x20acquire\x20locks,\x20they\x20\
1953 do\x20not\x20block\n\x20concurrent\x20read-write\x20transactions.\n\n\
1954 \x20Unlike\x20locking\x20read-write\x20transactions,\x20snapshot\x20read\
1955 -only\n\x20transactions\x20never\x20abort.\x20They\x20can\x20fail\x20if\
1956 \x20the\x20chosen\x20read\n\x20timestamp\x20is\x20garbage\x20collected;\
1957 \x20however,\x20the\x20default\x20garbage\n\x20collection\x20policy\x20i\
1958 s\x20generous\x20enough\x20that\x20most\x20applications\x20do\x20not\n\
1959 \x20need\x20to\x20worry\x20about\x20this\x20in\x20practice.\n\n\x20Snaps\
1960 hot\x20read-only\x20transactions\x20do\x20not\x20need\x20to\x20call\n\
1961 \x20[Commit][google.spanner.v1.Spanner.Commit]\x20or\n\x20[Rollback][goo\
1962 gle.spanner.v1.Spanner.Rollback]\x20(and\x20in\x20fact\x20are\x20not\n\
1963 \x20permitted\x20to\x20do\x20so).\n\n\x20To\x20execute\x20a\x20snapshot\
1964 \x20transaction,\x20the\x20client\x20specifies\x20a\x20timestamp\n\x20bo\
1965 und,\x20which\x20tells\x20Cloud\x20Spanner\x20how\x20to\x20choose\x20a\
1966 \x20read\x20timestamp.\n\n\x20The\x20types\x20of\x20timestamp\x20bound\
1967 \x20are:\n\n\x20\x20\x20-\x20Strong\x20(the\x20default).\n\x20\x20\x20-\
1968 \x20Bounded\x20staleness.\n\x20\x20\x20-\x20Exact\x20staleness.\n\n\x20I\
1969 f\x20the\x20Cloud\x20Spanner\x20database\x20to\x20be\x20read\x20is\x20ge\
1970 ographically\x20distributed,\n\x20stale\x20read-only\x20transactions\x20\
1971 can\x20execute\x20more\x20quickly\x20than\x20strong\n\x20or\x20read-writ\
1972 e\x20transactions,\x20because\x20they\x20are\x20able\x20to\x20execute\
1973 \x20far\n\x20from\x20the\x20leader\x20replica.\n\n\x20Each\x20type\x20of\
1974 \x20timestamp\x20bound\x20is\x20discussed\x20in\x20detail\x20below.\n\n\
1975 \x20Strong:\x20Strong\x20reads\x20are\x20guaranteed\x20to\x20see\x20the\
1976 \x20effects\x20of\x20all\x20transactions\n\x20that\x20have\x20committed\
1977 \x20before\x20the\x20start\x20of\x20the\x20read.\x20Furthermore,\x20all\
1978 \n\x20rows\x20yielded\x20by\x20a\x20single\x20read\x20are\x20consistent\
1979 \x20with\x20each\x20other\x20--\x20if\n\x20any\x20part\x20of\x20the\x20r\
1980 ead\x20observes\x20a\x20transaction,\x20all\x20parts\x20of\x20the\x20rea\
1981 d\n\x20see\x20the\x20transaction.\n\n\x20Strong\x20reads\x20are\x20not\
1982 \x20repeatable:\x20two\x20consecutive\x20strong\x20read-only\n\x20transa\
1983 ctions\x20might\x20return\x20inconsistent\x20results\x20if\x20there\x20a\
1984 re\n\x20concurrent\x20writes.\x20If\x20consistency\x20across\x20reads\
1985 \x20is\x20required,\x20the\n\x20reads\x20should\x20be\x20executed\x20wit\
1986 hin\x20a\x20transaction\x20or\x20at\x20an\x20exact\x20read\n\x20timestam\
1987 p.\n\n\x20Queries\x20on\x20change\x20streams\x20(see\x20below\x20for\x20\
1988 more\x20details)\x20must\x20also\x20specify\n\x20the\x20strong\x20read\
1989 \x20timestamp\x20bound.\n\n\x20See\n\x20[TransactionOptions.ReadOnly.str\
1990 ong][google.spanner.v1.TransactionOptions.ReadOnly.strong].\n\n\x20Exact\
1991 \x20staleness:\n\n\x20These\x20timestamp\x20bounds\x20execute\x20reads\
1992 \x20at\x20a\x20user-specified\n\x20timestamp.\x20Reads\x20at\x20a\x20tim\
1993 estamp\x20are\x20guaranteed\x20to\x20see\x20a\x20consistent\n\x20prefix\
1994 \x20of\x20the\x20global\x20transaction\x20history:\x20they\x20observe\n\
1995 \x20modifications\x20done\x20by\x20all\x20transactions\x20with\x20a\x20c\
1996 ommit\x20timestamp\x20less\x20than\x20or\n\x20equal\x20to\x20the\x20read\
1997 \x20timestamp,\x20and\x20observe\x20none\x20of\x20the\x20modifications\
1998 \x20done\x20by\n\x20transactions\x20with\x20a\x20larger\x20commit\x20tim\
1999 estamp.\x20They\x20will\x20block\x20until\n\x20all\x20conflicting\x20tra\
2000 nsactions\x20that\x20may\x20be\x20assigned\x20commit\x20timestamps\n\x20\
2001 <=\x20the\x20read\x20timestamp\x20have\x20finished.\n\n\x20The\x20timest\
2002 amp\x20can\x20either\x20be\x20expressed\x20as\x20an\x20absolute\x20Cloud\
2003 \x20Spanner\x20commit\n\x20timestamp\x20or\x20a\x20staleness\x20relative\
2004 \x20to\x20the\x20current\x20time.\n\n\x20These\x20modes\x20do\x20not\x20\
2005 require\x20a\x20\"negotiation\x20phase\"\x20to\x20pick\x20a\n\x20timesta\
2006 mp.\x20As\x20a\x20result,\x20they\x20execute\x20slightly\x20faster\x20th\
2007 an\x20the\n\x20equivalent\x20boundedly\x20stale\x20concurrency\x20modes.\
2008 \x20On\x20the\x20other\x20hand,\n\x20boundedly\x20stale\x20reads\x20usua\
2009 lly\x20return\x20fresher\x20results.\n\n\x20See\n\x20[TransactionOptions\
2010 .ReadOnly.read_timestamp][google.spanner.v1.TransactionOptions.ReadOnly.\
2011 read_timestamp]\n\x20and\n\x20[TransactionOptions.ReadOnly.exact_stalene\
2012 ss][google.spanner.v1.TransactionOptions.ReadOnly.exact_staleness].\n\n\
2013 \x20Bounded\x20staleness:\n\n\x20Bounded\x20staleness\x20modes\x20allow\
2014 \x20Cloud\x20Spanner\x20to\x20pick\x20the\x20read\x20timestamp,\n\x20sub\
2015 ject\x20to\x20a\x20user-provided\x20staleness\x20bound.\x20Cloud\x20Span\
2016 ner\x20chooses\x20the\n\x20newest\x20timestamp\x20within\x20the\x20stale\
2017 ness\x20bound\x20that\x20allows\x20execution\n\x20of\x20the\x20reads\x20\
2018 at\x20the\x20closest\x20available\x20replica\x20without\x20blocking.\n\n\
2019 \x20All\x20rows\x20yielded\x20are\x20consistent\x20with\x20each\x20other\
2020 \x20--\x20if\x20any\x20part\x20of\n\x20the\x20read\x20observes\x20a\x20t\
2021 ransaction,\x20all\x20parts\x20of\x20the\x20read\x20see\x20the\n\x20tran\
2022 saction.\x20Boundedly\x20stale\x20reads\x20are\x20not\x20repeatable:\x20\
2023 two\x20stale\n\x20reads,\x20even\x20if\x20they\x20use\x20the\x20same\x20\
2024 staleness\x20bound,\x20can\x20execute\x20at\n\x20different\x20timestamps\
2025 \x20and\x20thus\x20return\x20inconsistent\x20results.\n\n\x20Boundedly\
2026 \x20stale\x20reads\x20execute\x20in\x20two\x20phases:\x20the\x20first\
2027 \x20phase\n\x20negotiates\x20a\x20timestamp\x20among\x20all\x20replicas\
2028 \x20needed\x20to\x20serve\x20the\n\x20read.\x20In\x20the\x20second\x20ph\
2029 ase,\x20reads\x20are\x20executed\x20at\x20the\x20negotiated\n\x20timesta\
2030 mp.\n\n\x20As\x20a\x20result\x20of\x20the\x20two\x20phase\x20execution,\
2031 \x20bounded\x20staleness\x20reads\x20are\n\x20usually\x20a\x20little\x20\
2032 slower\x20than\x20comparable\x20exact\x20staleness\n\x20reads.\x20Howeve\
2033 r,\x20they\x20are\x20typically\x20able\x20to\x20return\x20fresher\n\x20r\
2034 esults,\x20and\x20are\x20more\x20likely\x20to\x20execute\x20at\x20the\
2035 \x20closest\x20replica.\n\n\x20Because\x20the\x20timestamp\x20negotiatio\
2036 n\x20requires\x20up-front\x20knowledge\x20of\n\x20which\x20rows\x20will\
2037 \x20be\x20read,\x20it\x20can\x20only\x20be\x20used\x20with\x20single-use\
2038 \n\x20read-only\x20transactions.\n\n\x20See\n\x20[TransactionOptions.Rea\
2039 dOnly.max_staleness][google.spanner.v1.TransactionOptions.ReadOnly.max_s\
2040 taleness]\n\x20and\n\x20[TransactionOptions.ReadOnly.min_read_timestamp]\
2041 [google.spanner.v1.TransactionOptions.ReadOnly.min_read_timestamp].\n\n\
2042 \x20Old\x20read\x20timestamps\x20and\x20garbage\x20collection:\n\n\x20Cl\
2043 oud\x20Spanner\x20continuously\x20garbage\x20collects\x20deleted\x20and\
2044 \x20overwritten\x20data\n\x20in\x20the\x20background\x20to\x20reclaim\
2045 \x20storage\x20space.\x20This\x20process\x20is\x20known\n\x20as\x20\"ver\
2046 sion\x20GC\".\x20By\x20default,\x20version\x20GC\x20reclaims\x20versions\
2047 \x20after\x20they\n\x20are\x20one\x20hour\x20old.\x20Because\x20of\x20th\
2048 is,\x20Cloud\x20Spanner\x20cannot\x20perform\x20reads\n\x20at\x20read\
2049 \x20timestamps\x20more\x20than\x20one\x20hour\x20in\x20the\x20past.\x20T\
2050 his\n\x20restriction\x20also\x20applies\x20to\x20in-progress\x20reads\
2051 \x20and/or\x20SQL\x20queries\x20whose\n\x20timestamp\x20become\x20too\
2052 \x20old\x20while\x20executing.\x20Reads\x20and\x20SQL\x20queries\x20with\
2053 \n\x20too-old\x20read\x20timestamps\x20fail\x20with\x20the\x20error\x20`\
2054 FAILED_PRECONDITION`.\n\n\x20You\x20can\x20configure\x20and\x20extend\
2055 \x20the\x20`VERSION_RETENTION_PERIOD`\x20of\x20a\n\x20database\x20up\x20\
2056 to\x20a\x20period\x20as\x20long\x20as\x20one\x20week,\x20which\x20allows\
2057 \x20Cloud\x20Spanner\n\x20to\x20perform\x20reads\x20up\x20to\x20one\x20w\
2058 eek\x20in\x20the\x20past.\n\n\x20Querying\x20change\x20Streams:\n\n\x20A\
2059 \x20Change\x20Stream\x20is\x20a\x20schema\x20object\x20that\x20can\x20be\
2060 \x20configured\x20to\x20watch\x20data\n\x20changes\x20on\x20the\x20entir\
2061 e\x20database,\x20a\x20set\x20of\x20tables,\x20or\x20a\x20set\x20of\x20c\
2062 olumns\n\x20in\x20a\x20database.\n\n\x20When\x20a\x20change\x20stream\
2063 \x20is\x20created,\x20Spanner\x20automatically\x20defines\x20a\n\x20corr\
2064 esponding\x20SQL\x20Table-Valued\x20Function\x20(TVF)\x20that\x20can\x20\
2065 be\x20used\x20to\x20query\n\x20the\x20change\x20records\x20in\x20the\x20\
2066 associated\x20change\x20stream\x20using\x20the\n\x20ExecuteStreamingSql\
2067 \x20API.\x20The\x20name\x20of\x20the\x20TVF\x20for\x20a\x20change\x20str\
2068 eam\x20is\n\x20generated\x20from\x20the\x20name\x20of\x20the\x20change\
2069 \x20stream:\x20READ_<change_stream_name>.\n\n\x20All\x20queries\x20on\
2070 \x20change\x20stream\x20TVFs\x20must\x20be\x20executed\x20using\x20the\n\
2071 \x20ExecuteStreamingSql\x20API\x20with\x20a\x20single-use\x20read-only\
2072 \x20transaction\x20with\x20a\n\x20strong\x20read-only\x20timestamp_bound\
2073 .\x20The\x20change\x20stream\x20TVF\x20allows\x20users\x20to\n\x20specif\
2074 y\x20the\x20start_timestamp\x20and\x20end_timestamp\x20for\x20the\x20tim\
2075 e\x20range\x20of\n\x20interest.\x20All\x20change\x20records\x20within\
2076 \x20the\x20retention\x20period\x20is\x20accessible\n\x20using\x20the\x20\
2077 strong\x20read-only\x20timestamp_bound.\x20All\x20other\x20TransactionOp\
2078 tions\n\x20are\x20invalid\x20for\x20change\x20stream\x20queries.\n\n\x20\
2079 In\x20addition,\x20if\x20TransactionOptions.read_only.return_read_timest\
2080 amp\x20is\x20set\n\x20to\x20true,\x20a\x20special\x20value\x20of\x202^63\
2081 \x20-\x202\x20will\x20be\x20returned\x20in\x20the\n\x20[Transaction][goo\
2082 gle.spanner.v1.Transaction]\x20message\x20that\x20describes\x20the\n\x20\
2083 transaction,\x20instead\x20of\x20a\x20valid\x20read\x20timestamp.\x20Thi\
2084 s\x20special\x20value\x20should\x20be\n\x20discarded\x20and\x20not\x20us\
2085 ed\x20for\x20any\x20subsequent\x20queries.\n\n\x20Please\x20see\x20https\
2086 ://cloud.google.com/spanner/docs/change-streams\n\x20for\x20more\x20deta\
2087 ils\x20on\x20how\x20to\x20query\x20the\x20change\x20stream\x20TVFs.\n\n\
2088 \x20Partitioned\x20DML\x20transactions:\n\n\x20Partitioned\x20DML\x20tra\
2089 nsactions\x20are\x20used\x20to\x20execute\x20DML\x20statements\x20with\
2090 \x20a\n\x20different\x20execution\x20strategy\x20that\x20provides\x20dif\
2091 ferent,\x20and\x20often\x20better,\n\x20scalability\x20properties\x20for\
2092 \x20large,\x20table-wide\x20operations\x20than\x20DML\x20in\x20a\n\x20Re\
2093 adWrite\x20transaction.\x20Smaller\x20scoped\x20statements,\x20such\x20a\
2094 s\x20an\x20OLTP\x20workload,\n\x20should\x20prefer\x20using\x20ReadWrite\
2095 \x20transactions.\n\n\x20Partitioned\x20DML\x20partitions\x20the\x20keys\
2096 pace\x20and\x20runs\x20the\x20DML\x20statement\x20on\x20each\n\x20partit\
2097 ion\x20in\x20separate,\x20internal\x20transactions.\x20These\x20transact\
2098 ions\x20commit\n\x20automatically\x20when\x20complete,\x20and\x20run\x20\
2099 independently\x20from\x20one\x20another.\n\n\x20To\x20reduce\x20lock\x20\
2100 contention,\x20this\x20execution\x20strategy\x20only\x20acquires\x20read\
2101 \x20locks\n\x20on\x20rows\x20that\x20match\x20the\x20WHERE\x20clause\x20\
2102 of\x20the\x20statement.\x20Additionally,\x20the\n\x20smaller\x20per-part\
2103 ition\x20transactions\x20hold\x20locks\x20for\x20less\x20time.\n\n\x20Th\
2104 at\x20said,\x20Partitioned\x20DML\x20is\x20not\x20a\x20drop-in\x20replac\
2105 ement\x20for\x20standard\x20DML\x20used\n\x20in\x20ReadWrite\x20transact\
2106 ions.\n\n\x20\x20-\x20The\x20DML\x20statement\x20must\x20be\x20fully-par\
2107 titionable.\x20Specifically,\x20the\x20statement\n\x20\x20\x20\x20must\
2108 \x20be\x20expressible\x20as\x20the\x20union\x20of\x20many\x20statements\
2109 \x20which\x20each\x20access\x20only\n\x20\x20\x20\x20a\x20single\x20row\
2110 \x20of\x20the\x20table.\n\n\x20\x20-\x20The\x20statement\x20is\x20not\
2111 \x20applied\x20atomically\x20to\x20all\x20rows\x20of\x20the\x20table.\
2112 \x20Rather,\n\x20\x20\x20\x20the\x20statement\x20is\x20applied\x20atomic\
2113 ally\x20to\x20partitions\x20of\x20the\x20table,\x20in\n\x20\x20\x20\x20i\
2114 ndependent\x20transactions.\x20Secondary\x20index\x20rows\x20are\x20upda\
2115 ted\x20atomically\n\x20\x20\x20\x20with\x20the\x20base\x20table\x20rows.\
2116 \n\n\x20\x20-\x20Partitioned\x20DML\x20does\x20not\x20guarantee\x20exact\
2117 ly-once\x20execution\x20semantics\n\x20\x20\x20\x20against\x20a\x20parti\
2118 tion.\x20The\x20statement\x20will\x20be\x20applied\x20at\x20least\x20onc\
2119 e\x20to\x20each\n\x20\x20\x20\x20partition.\x20It\x20is\x20strongly\x20r\
2120 ecommended\x20that\x20the\x20DML\x20statement\x20should\x20be\n\x20\x20\
2121 \x20\x20idempotent\x20to\x20avoid\x20unexpected\x20results.\x20For\x20in\
2122 stance,\x20it\x20is\x20potentially\n\x20\x20\x20\x20dangerous\x20to\x20r\
2123 un\x20a\x20statement\x20such\x20as\n\x20\x20\x20\x20`UPDATE\x20table\x20\
2124 SET\x20column\x20=\x20column\x20+\x201`\x20as\x20it\x20could\x20be\x20ru\
2125 n\x20multiple\x20times\n\x20\x20\x20\x20against\x20some\x20rows.\n\n\x20\
2126 \x20-\x20The\x20partitions\x20are\x20committed\x20automatically\x20-\x20\
2127 there\x20is\x20no\x20support\x20for\n\x20\x20\x20\x20Commit\x20or\x20Rol\
2128 lback.\x20If\x20the\x20call\x20returns\x20an\x20error,\x20or\x20if\x20th\
2129 e\x20client\x20issuing\n\x20\x20\x20\x20the\x20ExecuteSql\x20call\x20die\
2130 s,\x20it\x20is\x20possible\x20that\x20some\x20rows\x20had\x20the\x20stat\
2131 ement\n\x20\x20\x20\x20executed\x20on\x20them\x20successfully.\x20It\x20\
2132 is\x20also\x20possible\x20that\x20statement\x20was\n\x20\x20\x20\x20neve\
2133 r\x20executed\x20against\x20other\x20rows.\n\n\x20\x20-\x20Partitioned\
2134 \x20DML\x20transactions\x20may\x20only\x20contain\x20the\x20execution\
2135 \x20of\x20a\x20single\n\x20\x20\x20\x20DML\x20statement\x20via\x20Execut\
2136 eSql\x20or\x20ExecuteStreamingSql.\n\n\x20\x20-\x20If\x20any\x20error\
2137 \x20is\x20encountered\x20during\x20the\x20execution\x20of\x20the\x20part\
2138 itioned\x20DML\n\x20\x20\x20\x20operation\x20(for\x20instance,\x20a\x20U\
2139 NIQUE\x20INDEX\x20violation,\x20division\x20by\x20zero,\x20or\x20a\n\x20\
2140 \x20\x20\x20value\x20that\x20cannot\x20be\x20stored\x20due\x20to\x20sche\
2141 ma\x20constraints),\x20then\x20the\n\x20\x20\x20\x20operation\x20is\x20s\
2142 topped\x20at\x20that\x20point\x20and\x20an\x20error\x20is\x20returned.\
2143 \x20It\x20is\n\x20\x20\x20\x20possible\x20that\x20at\x20this\x20point,\
2144 \x20some\x20partitions\x20have\x20been\x20committed\x20(or\x20even\n\x20\
2145 \x20\x20\x20committed\x20multiple\x20times),\x20and\x20other\x20partitio\
2146 ns\x20have\x20not\x20been\x20run\x20at\x20all.\n\n\x20Given\x20the\x20ab\
2147 ove,\x20Partitioned\x20DML\x20is\x20good\x20fit\x20for\x20large,\x20data\
2148 base-wide,\n\x20operations\x20that\x20are\x20idempotent,\x20such\x20as\
2149 \x20deleting\x20old\x20rows\x20from\x20a\x20very\x20large\n\x20table.\n\
2150 \n\x0b\n\x03\x04\0\x01\x12\x04\xe1\x02\x08\x1a\nu\n\x04\x04\0\x03\0\x12\
2151 \x06\xe4\x02\x02\xfc\x02\x03\x1ae\x20Message\x20type\x20to\x20initiate\
2152 \x20a\x20read-write\x20transaction.\x20Currently\x20this\n\x20transactio\
2153 n\x20type\x20has\x20no\x20options.\n\n\r\n\x05\x04\0\x03\0\x01\x12\x04\
2154 \xe4\x02\n\x13\nb\n\x06\x04\0\x03\0\x04\0\x12\x06\xe7\x02\x04\xf8\x02\
2155 \x05\x1aP\x20`ReadLockMode`\x20is\x20used\x20to\x20set\x20the\x20read\
2156 \x20lock\x20mode\x20for\x20read-write\n\x20transactions.\n\n\x0f\n\x07\
2157 \x04\0\x03\0\x04\0\x01\x12\x04\xe7\x02\t\x15\nf\n\x08\x04\0\x03\0\x04\0\
2158 \x02\0\x12\x04\xeb\x02\x06%\x1aT\x20Default\x20value.\n\n\x20If\x20the\
2159 \x20value\x20is\x20not\x20specified,\x20the\x20pessimistic\x20read\x20lo\
2160 ck\x20is\x20used.\n\n\x11\n\t\x04\0\x03\0\x04\0\x02\0\x01\x12\x04\xeb\
2161 \x02\x06\x20\n\x11\n\t\x04\0\x03\0\x04\0\x02\0\x02\x12\x04\xeb\x02#$\nY\
2162 \n\x08\x04\0\x03\0\x04\0\x02\x01\x12\x04\xf0\x02\x06\x16\x1aG\x20Pessimi\
2163 stic\x20lock\x20mode.\n\n\x20Read\x20locks\x20are\x20acquired\x20immedia\
2164 tely\x20on\x20read.\n\n\x11\n\t\x04\0\x03\0\x04\0\x02\x01\x01\x12\x04\
2165 \xf0\x02\x06\x11\n\x11\n\t\x04\0\x03\0\x04\0\x02\x01\x02\x12\x04\xf0\x02\
2166 \x14\x15\n\xec\x01\n\x08\x04\0\x03\0\x04\0\x02\x02\x12\x04\xf7\x02\x06\
2167 \x15\x1a\xd9\x01\x20Optimistic\x20lock\x20mode.\n\n\x20Locks\x20for\x20r\
2168 eads\x20within\x20the\x20transaction\x20are\x20not\x20acquired\x20on\x20\
2169 read.\n\x20Instead\x20the\x20locks\x20are\x20acquired\x20on\x20a\x20comm\
2170 it\x20to\x20validate\x20that\n\x20read/queried\x20data\x20has\x20not\x20\
2171 changed\x20since\x20the\x20transaction\x20started.\n\n\x11\n\t\x04\0\x03\
2172 \0\x04\0\x02\x02\x01\x12\x04\xf7\x02\x06\x10\n\x11\n\t\x04\0\x03\0\x04\0\
2173 \x02\x02\x02\x12\x04\xf7\x02\x13\x14\n5\n\x06\x04\0\x03\0\x02\0\x12\x04\
2174 \xfb\x02\x04$\x1a%\x20Read\x20lock\x20mode\x20for\x20the\x20transaction.\
2175 \n\n\x0f\n\x07\x04\0\x03\0\x02\0\x06\x12\x04\xfb\x02\x04\x10\n\x0f\n\x07\
2176 \x04\0\x03\0\x02\0\x01\x12\x04\xfb\x02\x11\x1f\n\x0f\n\x07\x04\0\x03\0\
2177 \x02\0\x03\x12\x04\xfb\x02\"#\nG\n\x04\x04\0\x03\x01\x12\x04\xff\x02\x02\
2178 \x1b\x1a9\x20Message\x20type\x20to\x20initiate\x20a\x20Partitioned\x20DM\
2179 L\x20transaction.\n\n\r\n\x05\x04\0\x03\x01\x01\x12\x04\xff\x02\n\x18\nC\
2180 \n\x04\x04\0\x03\x02\x12\x06\x82\x03\x02\xc4\x03\x03\x1a3\x20Message\x20\
2181 type\x20to\x20initiate\x20a\x20read-only\x20transaction.\n\n\r\n\x05\x04\
2182 \0\x03\x02\x01\x12\x04\x82\x03\n\x12\nN\n\x06\x04\0\x03\x02\x08\0\x12\
2183 \x06\x84\x03\x04\xbe\x03\x05\x1a<\x20How\x20to\x20choose\x20the\x20times\
2184 tamp\x20for\x20the\x20read-only\x20transaction.\n\n\x0f\n\x07\x04\0\x03\
2185 \x02\x08\0\x01\x12\x04\x84\x03\n\x19\n_\n\x06\x04\0\x03\x02\x02\0\x12\
2186 \x04\x87\x03\x06\x16\x1aO\x20Read\x20at\x20a\x20timestamp\x20where\x20al\
2187 l\x20previously\x20committed\x20transactions\n\x20are\x20visible.\n\n\
2188 \x0f\n\x07\x04\0\x03\x02\x02\0\x05\x12\x04\x87\x03\x06\n\n\x0f\n\x07\x04\
2189 \0\x03\x02\x02\0\x01\x12\x04\x87\x03\x0b\x11\n\x0f\n\x07\x04\0\x03\x02\
2190 \x02\0\x03\x12\x04\x87\x03\x14\x15\n\xc6\x03\n\x06\x04\0\x03\x02\x02\x01\
2191 \x12\x04\x93\x03\x067\x1a\xb5\x03\x20Executes\x20all\x20reads\x20at\x20a\
2192 \x20timestamp\x20>=\x20`min_read_timestamp`.\n\n\x20This\x20is\x20useful\
2193 \x20for\x20requesting\x20fresher\x20data\x20than\x20some\x20previous\n\
2194 \x20read,\x20or\x20data\x20that\x20is\x20fresh\x20enough\x20to\x20observ\
2195 e\x20the\x20effects\x20of\x20some\n\x20previously\x20committed\x20transa\
2196 ction\x20whose\x20timestamp\x20is\x20known.\n\n\x20Note\x20that\x20this\
2197 \x20option\x20can\x20only\x20be\x20used\x20in\x20single-use\x20transacti\
2198 ons.\n\n\x20A\x20timestamp\x20in\x20RFC3339\x20UTC\x20\\\"Zulu\\\"\x20fo\
2199 rmat,\x20accurate\x20to\x20nanoseconds.\n\x20Example:\x20`\"2014-10-02T1\
2200 5:01:23.045123456Z\"`.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x01\x06\x12\x04\
2201 \x93\x03\x06\x1f\n\x0f\n\x07\x04\0\x03\x02\x02\x01\x01\x12\x04\x93\x03\
2202 \x202\n\x0f\n\x07\x04\0\x03\x02\x02\x01\x03\x12\x04\x93\x0356\n\xba\x04\
2203 \n\x06\x04\0\x03\x02\x02\x02\x12\x04\xa2\x03\x061\x1a\xa9\x04\x20Read\
2204 \x20data\x20at\x20a\x20timestamp\x20>=\x20`NOW\x20-\x20max_staleness`\n\
2205 \x20seconds.\x20Guarantees\x20that\x20all\x20writes\x20that\x20have\x20c\
2206 ommitted\x20more\n\x20than\x20the\x20specified\x20number\x20of\x20second\
2207 s\x20ago\x20are\x20visible.\x20Because\n\x20Cloud\x20Spanner\x20chooses\
2208 \x20the\x20exact\x20timestamp,\x20this\x20mode\x20works\x20even\x20if\n\
2209 \x20the\x20client's\x20local\x20clock\x20is\x20substantially\x20skewed\
2210 \x20from\x20Cloud\x20Spanner\n\x20commit\x20timestamps.\n\n\x20Useful\
2211 \x20for\x20reading\x20the\x20freshest\x20data\x20available\x20at\x20a\
2212 \x20nearby\n\x20replica,\x20while\x20bounding\x20the\x20possible\x20stal\
2213 eness\x20if\x20the\x20local\n\x20replica\x20has\x20fallen\x20behind.\n\n\
2214 \x20Note\x20that\x20this\x20option\x20can\x20only\x20be\x20used\x20in\
2215 \x20single-use\n\x20transactions.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x02\
2216 \x06\x12\x04\xa2\x03\x06\x1e\n\x0f\n\x07\x04\0\x03\x02\x02\x02\x01\x12\
2217 \x04\xa2\x03\x1f,\n\x0f\n\x07\x04\0\x03\x02\x02\x02\x03\x12\x04\xa2\x03/\
2218 0\n\xb6\x04\n\x06\x04\0\x03\x02\x02\x03\x12\x04\xb0\x03\x063\x1a\xa5\x04\
2219 \x20Executes\x20all\x20reads\x20at\x20the\x20given\x20timestamp.\x20Unli\
2220 ke\x20other\x20modes,\n\x20reads\x20at\x20a\x20specific\x20timestamp\x20\
2221 are\x20repeatable;\x20the\x20same\x20read\x20at\n\x20the\x20same\x20time\
2222 stamp\x20always\x20returns\x20the\x20same\x20data.\x20If\x20the\n\x20tim\
2223 estamp\x20is\x20in\x20the\x20future,\x20the\x20read\x20will\x20block\x20\
2224 until\x20the\n\x20specified\x20timestamp,\x20modulo\x20the\x20read's\x20\
2225 deadline.\n\n\x20Useful\x20for\x20large\x20scale\x20consistent\x20reads\
2226 \x20such\x20as\x20mapreduces,\x20or\n\x20for\x20coordinating\x20many\x20\
2227 reads\x20against\x20a\x20consistent\x20snapshot\x20of\x20the\n\x20data.\
2228 \n\n\x20A\x20timestamp\x20in\x20RFC3339\x20UTC\x20\\\"Zulu\\\"\x20format\
2229 ,\x20accurate\x20to\x20nanoseconds.\n\x20Example:\x20`\"2014-10-02T15:01\
2230 :23.045123456Z\"`.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x03\x06\x12\x04\xb0\
2231 \x03\x06\x1f\n\x0f\n\x07\x04\0\x03\x02\x02\x03\x01\x12\x04\xb0\x03\x20.\
2232 \n\x0f\n\x07\x04\0\x03\x02\x02\x03\x03\x12\x04\xb0\x0312\n\x92\x04\n\x06\
2233 \x04\0\x03\x02\x02\x04\x12\x04\xbd\x03\x063\x1a\x81\x04\x20Executes\x20a\
2234 ll\x20reads\x20at\x20a\x20timestamp\x20that\x20is\x20`exact_staleness`\n\
2235 \x20old.\x20The\x20timestamp\x20is\x20chosen\x20soon\x20after\x20the\x20\
2236 read\x20is\x20started.\n\n\x20Guarantees\x20that\x20all\x20writes\x20tha\
2237 t\x20have\x20committed\x20more\x20than\x20the\n\x20specified\x20number\
2238 \x20of\x20seconds\x20ago\x20are\x20visible.\x20Because\x20Cloud\x20Spann\
2239 er\n\x20chooses\x20the\x20exact\x20timestamp,\x20this\x20mode\x20works\
2240 \x20even\x20if\x20the\x20client's\n\x20local\x20clock\x20is\x20substanti\
2241 ally\x20skewed\x20from\x20Cloud\x20Spanner\x20commit\n\x20timestamps.\n\
2242 \n\x20Useful\x20for\x20reading\x20at\x20nearby\x20replicas\x20without\
2243 \x20the\x20distributed\n\x20timestamp\x20negotiation\x20overhead\x20of\
2244 \x20`max_staleness`.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x04\x06\x12\x04\xbd\
2245 \x03\x06\x1e\n\x0f\n\x07\x04\0\x03\x02\x02\x04\x01\x12\x04\xbd\x03\x1f.\
2246 \n\x0f\n\x07\x04\0\x03\x02\x02\x04\x03\x12\x04\xbd\x0312\n\xaf\x01\n\x06\
2247 \x04\0\x03\x02\x02\x05\x12\x04\xc3\x03\x04#\x1a\x9e\x01\x20If\x20true,\
2248 \x20the\x20Cloud\x20Spanner-selected\x20read\x20timestamp\x20is\x20inclu\
2249 ded\x20in\n\x20the\x20[Transaction][google.spanner.v1.Transaction]\x20me\
2250 ssage\x20that\x20describes\n\x20the\x20transaction.\n\n\x0f\n\x07\x04\0\
2251 \x03\x02\x02\x05\x05\x12\x04\xc3\x03\x04\x08\n\x0f\n\x07\x04\0\x03\x02\
2252 \x02\x05\x01\x12\x04\xc3\x03\t\x1e\n\x0f\n\x07\x04\0\x03\x02\x02\x05\x03\
2253 \x12\x04\xc3\x03!\"\n4\n\x04\x04\0\x08\0\x12\x06\xc7\x03\x02\xdc\x03\x03\
2254 \x1a$\x20Required.\x20The\x20type\x20of\x20transaction.\n\n\r\n\x05\x04\
2255 \0\x08\0\x01\x12\x04\xc7\x03\x08\x0c\n\xc2\x01\n\x04\x04\0\x02\0\x12\x04\
2256 \xcd\x03\x04\x1d\x1a\xb3\x01\x20Transaction\x20may\x20write.\n\n\x20Auth\
2257 orization\x20to\x20begin\x20a\x20read-write\x20transaction\x20requires\n\
2258 \x20`spanner.databases.beginOrRollbackReadWriteTransaction`\x20permissio\
2259 n\n\x20on\x20the\x20`session`\x20resource.\n\n\r\n\x05\x04\0\x02\0\x06\
2260 \x12\x04\xcd\x03\x04\r\n\r\n\x05\x04\0\x02\0\x01\x12\x04\xcd\x03\x0e\x18\
2261 \n\r\n\x05\x04\0\x02\0\x03\x12\x04\xcd\x03\x1b\x1c\n\xc8\x01\n\x04\x04\0\
2262 \x02\x01\x12\x04\xd4\x03\x04'\x1a\xb9\x01\x20Partitioned\x20DML\x20trans\
2263 action.\n\n\x20Authorization\x20to\x20begin\x20a\x20Partitioned\x20DML\
2264 \x20transaction\x20requires\n\x20`spanner.databases.beginPartitionedDmlT\
2265 ransaction`\x20permission\n\x20on\x20the\x20`session`\x20resource.\n\n\r\
2266 \n\x05\x04\0\x02\x01\x06\x12\x04\xd4\x03\x04\x12\n\r\n\x05\x04\0\x02\x01\
2267 \x01\x12\x04\xd4\x03\x13\"\n\r\n\x05\x04\0\x02\x01\x03\x12\x04\xd4\x03%&\
2268 \n\xbb\x01\n\x04\x04\0\x02\x02\x12\x04\xdb\x03\x04\x1b\x1a\xac\x01\x20Tr\
2269 ansaction\x20will\x20not\x20write.\n\n\x20Authorization\x20to\x20begin\
2270 \x20a\x20read-only\x20transaction\x20requires\n\x20`spanner.databases.be\
2271 ginReadOnlyTransaction`\x20permission\n\x20on\x20the\x20`session`\x20res\
2272 ource.\n\n\r\n\x05\x04\0\x02\x02\x06\x12\x04\xdb\x03\x04\x0c\n\r\n\x05\
2273 \x04\0\x02\x02\x01\x12\x04\xdb\x03\r\x16\n\r\n\x05\x04\0\x02\x02\x03\x12\
2274 \x04\xdb\x03\x19\x1a\n\x1e\n\x02\x04\x01\x12\x06\xe0\x03\0\xf2\x03\x01\
2275 \x1a\x10\x20A\x20transaction.\n\n\x0b\n\x03\x04\x01\x01\x12\x04\xe0\x03\
2276 \x08\x13\n\x88\x03\n\x04\x04\x01\x02\0\x12\x04\xe9\x03\x02\x0f\x1a\xf9\
2277 \x02\x20`id`\x20may\x20be\x20used\x20to\x20identify\x20the\x20transactio\
2278 n\x20in\x20subsequent\n\x20[Read][google.spanner.v1.Spanner.Read],\n\x20\
2279 [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql],\n\x20[Commit][google\
2280 .spanner.v1.Spanner.Commit],\x20or\n\x20[Rollback][google.spanner.v1.Spa\
2281 nner.Rollback]\x20calls.\n\n\x20Single-use\x20read-only\x20transactions\
2282 \x20do\x20not\x20have\x20IDs,\x20because\n\x20single-use\x20transactions\
2283 \x20do\x20not\x20support\x20multiple\x20requests.\n\n\r\n\x05\x04\x01\
2284 \x02\0\x05\x12\x04\xe9\x03\x02\x07\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\
2285 \xe9\x03\x08\n\n\r\n\x05\x04\x01\x02\0\x03\x12\x04\xe9\x03\r\x0e\n\xf2\
2286 \x02\n\x04\x04\x01\x02\x01\x12\x04\xf1\x03\x02/\x1a\xe3\x02\x20For\x20sn\
2287 apshot\x20read-only\x20transactions,\x20the\x20read\x20timestamp\x20chos\
2288 en\n\x20for\x20the\x20transaction.\x20Not\x20returned\x20by\x20default:\
2289 \x20see\n\x20[TransactionOptions.ReadOnly.return_read_timestamp][google.\
2290 spanner.v1.TransactionOptions.ReadOnly.return_read_timestamp].\n\n\x20A\
2291 \x20timestamp\x20in\x20RFC3339\x20UTC\x20\\\"Zulu\\\"\x20format,\x20accu\
2292 rate\x20to\x20nanoseconds.\n\x20Example:\x20`\"2014-10-02T15:01:23.04512\
2293 3456Z\"`.\n\n\r\n\x05\x04\x01\x02\x01\x06\x12\x04\xf1\x03\x02\x1b\n\r\n\
2294 \x05\x04\x01\x02\x01\x01\x12\x04\xf1\x03\x1c*\n\r\n\x05\x04\x01\x02\x01\
2295 \x03\x12\x04\xf1\x03-.\n\x9f\x02\n\x02\x04\x02\x12\x06\xfa\x03\0\x8c\x04\
2296 \x01\x1a\x90\x02\x20This\x20message\x20is\x20used\x20to\x20select\x20the\
2297 \x20transaction\x20in\x20which\x20a\n\x20[Read][google.spanner.v1.Spanne\
2298 r.Read]\x20or\n\x20[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql]\
2299 \x20call\x20runs.\n\n\x20See\x20[TransactionOptions][google.spanner.v1.T\
2300 ransactionOptions]\x20for\x20more\n\x20information\x20about\x20transacti\
2301 ons.\n\n\x0b\n\x03\x04\x02\x01\x12\x04\xfa\x03\x08\x1b\ni\n\x04\x04\x02\
2302 \x08\0\x12\x06\xfd\x03\x02\x8b\x04\x03\x1aY\x20If\x20no\x20fields\x20are\
2303 \x20set,\x20the\x20default\x20is\x20a\x20single\x20use\x20transaction\n\
2304 \x20with\x20strong\x20concurrency.\n\n\r\n\x05\x04\x02\x08\0\x01\x12\x04\
2305 \xfd\x03\x08\x10\n\xa9\x01\n\x04\x04\x02\x02\0\x12\x04\x81\x04\x04&\x1a\
2306 \x9a\x01\x20Execute\x20the\x20read\x20or\x20SQL\x20query\x20in\x20a\x20t\
2307 emporary\x20transaction.\n\x20This\x20is\x20the\x20most\x20efficient\x20\
2308 way\x20to\x20execute\x20a\x20transaction\x20that\n\x20consists\x20of\x20\
2309 a\x20single\x20SQL\x20query.\n\n\r\n\x05\x04\x02\x02\0\x06\x12\x04\x81\
2310 \x04\x04\x16\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\x81\x04\x17!\n\r\n\x05\
2311 \x04\x02\x02\0\x03\x12\x04\x81\x04$%\nR\n\x04\x04\x02\x02\x01\x12\x04\
2312 \x84\x04\x04\x11\x1aD\x20Execute\x20the\x20read\x20or\x20SQL\x20query\
2313 \x20in\x20a\x20previously-started\x20transaction.\n\n\r\n\x05\x04\x02\
2314 \x02\x01\x05\x12\x04\x84\x04\x04\t\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\
2315 \x84\x04\n\x0c\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\x84\x04\x0f\x10\n\
2316 \x99\x02\n\x04\x04\x02\x02\x02\x12\x04\x8a\x04\x04!\x1a\x8a\x02\x20Begin\
2317 \x20a\x20new\x20transaction\x20and\x20execute\x20this\x20read\x20or\x20S\
2318 QL\x20query\x20in\n\x20it.\x20The\x20transaction\x20ID\x20of\x20the\x20n\
2319 ew\x20transaction\x20is\x20returned\x20in\n\x20[ResultSetMetadata.transa\
2320 ction][google.spanner.v1.ResultSetMetadata.transaction],\n\x20which\x20i\
2321 s\x20a\x20[Transaction][google.spanner.v1.Transaction].\n\n\r\n\x05\x04\
2322 \x02\x02\x02\x06\x12\x04\x8a\x04\x04\x16\n\r\n\x05\x04\x02\x02\x02\x01\
2323 \x12\x04\x8a\x04\x17\x1c\n\r\n\x05\x04\x02\x02\x02\x03\x12\x04\x8a\x04\
2324 \x1f\x20b\x06proto3\
2325";
2326
2327static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
2328
2329fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
2330 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
2331}
2332
2333pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
2334 file_descriptor_proto_lazy.get(|| {
2335 parse_descriptor_proto()
2336 })
2337}