impl(spanner): introduce concurrency control options

This adds support for Transaction_ReadWriteOptions_ReadLockMode by adding
a constructor of ReadWriteOptions with a special enum, whose values
can be "optimistic", "pessimistic" and "unspecified".

Author: diegomarquezp

google/cloud/spanner/transaction.cc

@@ -34,6 +34,10 @@ google::protobuf::Duration ToProto(std::chrono::nanoseconds ns) {
   return proto;
 }
 
+google::spanner::v1::TransactionOptions_ReadWrite_ReadLockMode ToProto(Transaction::ReadLockMode read_lock_mode) {
+  return static_cast<google::spanner::v1::TransactionOptions_ReadWrite_ReadLockMode>(read_lock_mode);
+}
+
 google::spanner::v1::TransactionOptions MakeOpts(
     google::spanner::v1::TransactionOptions_ReadOnly ro_opts) {
   google::spanner::v1::TransactionOptions opts;
@@ -71,14 +75,20 @@ Transaction::ReadOnlyOptions::ReadOnlyOptions(
   ro_opts_.set_return_read_timestamp(true);
 }
 
-Transaction::ReadWriteOptions::ReadWriteOptions() = default;  // currently none
+Transaction::ReadWriteOptions::ReadWriteOptions() = default;
+
+Transaction::ReadWriteOptions::ReadWriteOptions(
+    ReadLockMode read_lock_mode) {
+  rw_opts_.set_read_lock_mode(ToProto(read_lock_mode));
+}
 
 Transaction::ReadWriteOptions& Transaction::ReadWriteOptions::WithTag(
     absl::optional<std::string> tag) {
   tag_ = std::move(tag);
   return *this;
 }
 
+
 Transaction::SingleUseOptions::SingleUseOptions(ReadOnlyOptions opts) {
   ro_opts_ = std::move(opts.ro_opts_);
 }

google/cloud/spanner/transaction.h

@@ -78,14 +78,28 @@ class Transaction {
     google::spanner::v1::TransactionOptions_ReadOnly ro_opts_;
   };
 
+  /**
+   * Read lock mode for ReadWrite transactions
+   * The Spanner V1 Transaction proto classes have their own enum
+   * implementations.
+   * See google::spanner::v1::TransactionOptions_ReadWrite_ReadLockMode
+   * This is a shorthand convenience for the developer.
+   */
+  enum class ReadLockMode {
+    kUnspecified,
+    kPessimistic,
+    kOptimistic,
+  };
+
   /**
    * Options for ReadWrite transactions.
    */
   class ReadWriteOptions {
    public:
-    // There are currently no read-write options.
     ReadWriteOptions();
 
+    ReadWriteOptions(ReadLockMode read_lock_mode);
+
     // A tag used for collecting statistics about the transaction.
     ReadWriteOptions& WithTag(absl::optional<std::string> tag);
 

google/cloud/spanner/transaction_test.cc

@@ -27,12 +27,14 @@ using ::testing::IsEmpty;
 TEST(TransactionOptions, Construction) {
   Timestamp read_timestamp{};
   std::chrono::nanoseconds staleness{};
+  auto read_lock_mode = Transaction::ReadLockMode::kOptimistic;
 
   Transaction::ReadOnlyOptions strong;
   Transaction::ReadOnlyOptions exact_ts(read_timestamp);
   Transaction::ReadOnlyOptions exact_dur(staleness);
 
   Transaction::ReadWriteOptions none;
+  Transaction::ReadWriteOptions rw_with_read_lock(read_lock_mode);
 
   Transaction::SingleUseOptions su_strong(strong);
   Transaction::SingleUseOptions su_exact_ts(exact_ts);
@@ -130,6 +132,47 @@ TEST(Transaction, SessionAffinity) {
       });
 }
 
+TEST(Transaction, ReadWriteOptions_WithTag) {
+  auto opts = Transaction::ReadWriteOptions().WithTag("test-tag");
+  Transaction txn = MakeReadWriteTransaction(opts);
+  spanner_internal::Visit(
+      txn, [&](spanner_internal::SessionHolder& /*session*/,
+               StatusOr<google::spanner::v1::TransactionSelector>& s,
+               spanner_internal::TransactionContext const& ctx) {
+        EXPECT_TRUE(s->has_begin());
+        EXPECT_TRUE(s->begin().has_read_write());
+        EXPECT_EQ(ctx.tag, "test-tag");
+        return 0;
+      });
+}
+
+TEST(Transaction, ReadWriteOptions_WithReadLockMode) {
+  auto check_lock_mode =
+      [](Transaction::ReadLockMode mode,
+         google::spanner::v1::TransactionOptions_ReadWrite_ReadLockMode
+             expected_proto_mode) {
+        auto opts = Transaction::ReadWriteOptions(mode);
+        Transaction txn = MakeReadWriteTransaction(opts);
+        spanner_internal::Visit(
+            txn, [&](spanner_internal::SessionHolder& /*session*/,
+                     StatusOr<google::spanner::v1::TransactionSelector>& s,
+                     spanner_internal::TransactionContext const& /*ctx*/) {
+              EXPECT_TRUE(s->has_begin());
+              EXPECT_TRUE(s->begin().has_read_write());
+              EXPECT_EQ(s->begin().read_write().read_lock_mode(),
+                        expected_proto_mode);
+              return 0;
+            });
+      };
+
+  check_lock_mode(
+      Transaction::ReadLockMode::kPessimistic,
+      google::spanner::v1::TransactionOptions_ReadWrite::PESSIMISTIC);
+  check_lock_mode(
+      Transaction::ReadLockMode::kOptimistic,
+      google::spanner::v1::TransactionOptions_ReadWrite::OPTIMISTIC);
+}
+
 }  // namespace
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace spanner