diff --git a/google/cloud/bigtable/value.cc b/google/cloud/bigtable/value.cc
index 0fea5cada96c7..4190d293cb036 100644
--- a/google/cloud/bigtable/value.cc
+++ b/google/cloud/bigtable/value.cc
@@ -50,6 +50,24 @@ std::string AsString(T&& s) {
       std::move(s));  // NOLINT(bugprone-move-forwarding-reference)
 }
 
+// Forward declarations for mutually recursive functions.
+bool Equal(google::bigtable::v2::Type const& pt1,  // NOLINT(misc-no-recursion)
+           google::bigtable::v2::Value const& pv1,
+           google::bigtable::v2::Type const& pt2,
+           google::bigtable::v2::Value const& pv2);
+
+bool ArrayEqual(  // NOLINT(misc-no-recursion)
+    google::bigtable::v2::Type const& pt1,
+    google::bigtable::v2::Value const& pv1,
+    google::bigtable::v2::Type const& pt2,
+    google::bigtable::v2::Value const& pv2);
+
+bool StructEqual(  // NOLINT(misc-no-recursion)
+    google::bigtable::v2::Type const& pt1,
+    google::bigtable::v2::Value const& pv1,
+    google::bigtable::v2::Type const& pt2,
+    google::bigtable::v2::Value const& pv2);
+
 // Compares two sets of Type and Value protos for equality. This method calls
 // itself recursively to compare subtypes and subvalues.
 bool Equal(google::bigtable::v2::Type const& pt1,  // NOLINT(misc-no-recursion)
@@ -83,24 +101,61 @@ bool Equal(google::bigtable::v2::Type const& pt1,  // NOLINT(misc-no-recursion)
            pv1.date_value().year() == pv2.date_value().year();
   }
   if (pt1.has_array_type()) {
-    auto const& vec1 = pv1.array_value().values();
-    auto const& vec2 = pv2.array_value().values();
-    if (vec1.size() != vec2.size()) {
+    return ArrayEqual(pt1, pv1, pt2, pv2);
+  }
+  if (pt1.has_struct_type()) {
+    return StructEqual(pt1, pv1, pt2, pv2);
+  }
+  return false;
+}
+
+// Compares two sets of Type and Value protos that represent an ARRAY for
+// equality.
+bool ArrayEqual(  // NOLINT(misc-no-recursion)
+    google::bigtable::v2::Type const& pt1,
+    google::bigtable::v2::Value const& pv1,
+    google::bigtable::v2::Type const& pt2,
+    google::bigtable::v2::Value const& pv2) {
+  auto const& vec1 = pv1.array_value().values();
+  auto const& vec2 = pv2.array_value().values();
+  if (vec1.size() != vec2.size()) {
+    return false;
+  }
+  auto const& el_type1 = pt1.array_type().element_type();
+  auto const& el_type2 = pt2.array_type().element_type();
+  if (el_type1.kind_case() != el_type2.kind_case()) {
+    return false;
+  }
+  for (int i = 0; i < vec1.size(); ++i) {
+    if (!Equal(el_type1, vec1.Get(i), el_type2, vec2.Get(i))) {
       return false;
     }
-    auto const& el_type1 = pt1.array_type().element_type();
-    auto const& el_type2 = pt2.array_type().element_type();
-    if (el_type1.kind_case() != el_type2.kind_case()) {
+  }
+  return true;
+}
+
+// Compares two sets of Type and Value protos that represent a STRUCT for
+// equality.
+bool StructEqual(  // NOLINT(misc-no-recursion)
+    google::bigtable::v2::Type const& pt1,
+    google::bigtable::v2::Value const& pv1,
+    google::bigtable::v2::Type const& pt2,
+    google::bigtable::v2::Value const& pv2) {
+  auto const& fields1 = pt1.struct_type().fields();
+  auto const& fields2 = pt2.struct_type().fields();
+  if (fields1.size() != fields2.size()) return false;
+  auto const& v1 = pv1.array_value().values();
+  auto const& v2 = pv2.array_value().values();
+  if (fields1.size() != v1.size() || v1.size() != v2.size()) return false;
+  for (int i = 0; i < fields1.size(); ++i) {
+    auto const& f1 = fields1.Get(i);
+    auto const& f2 = fields2.Get(i);
+    if (f1.field_name() != f2.field_name()) return false;
+    if (!Equal(f1.type(), v1.Get(i), f2.type(), v2.Get(i))) {
       return false;
     }
-    for (int i = 0; i < vec1.size(); ++i) {
-      if (!Equal(el_type1, vec1.Get(i), el_type2, vec2.Get(i))) {
-        return false;
-      }
-    }
-    return true;
   }
-  return false;
+  return true;
 }
 
 // From the proto description, `NULL` values are represented by having a kind
@@ -133,16 +188,17 @@ std::ostream& StreamHelper(std::ostream& os,  // NOLINT(misc-no-recursion)
     return os << "NULL";
   }
 
-  if (v.kind_case() == google::bigtable::v2::Value::kBoolValue) {
+  if (t.kind_case() == google::bigtable::v2::Type::kBoolType) {
     return os << v.bool_value();
   }
-  if (v.kind_case() == google::bigtable::v2::Value::kIntValue) {
+  if (t.kind_case() == google::bigtable::v2::Type::kInt64Type) {
     return os << v.int_value();
   }
-  if (v.kind_case() == google::bigtable::v2::Value::kFloatValue) {
+  if (t.kind_case() == google::bigtable::v2::Type::kFloat32Type ||
+      t.kind_case() == google::bigtable::v2::Type::kFloat64Type) {
     return os << v.float_value();
   }
-  if (v.kind_case() == google::bigtable::v2::Value::kStringValue) {
+  if (t.kind_case() == google::bigtable::v2::Type::kStringType) {
     switch (mode) {
       case StreamMode::kScalar:
         return os << v.string_value();
@@ -153,22 +209,22 @@ std::ostream& StreamHelper(std::ostream& os,  // NOLINT(misc-no-recursion)
     }
     return os;  // Unreachable, but quiets warning.
   }
-  if (v.kind_case() == google::bigtable::v2::Value::kBytesValue) {
+  if (t.kind_case() == google::bigtable::v2::Type::kBytesType) {
     return os << Bytes(AsString(v.bytes_value()));
   }
-  if (v.kind_case() == google::bigtable::v2::Value::kTimestampValue) {
+  if (t.kind_case() == google::bigtable::v2::Type::kTimestampType) {
     auto ts = MakeTimestamp(v.timestamp_value());
     if (!ts) {
       internal::ThrowStatus(ts.status());
     }
     return os << ts.value();
   }
-  if (v.kind_case() == google::bigtable::v2::Value::kDateValue) {
+  if (t.kind_case() == google::bigtable::v2::Type::kDateType) {
     auto date =
         bigtable_internal::FromProto(t, v).get<absl::CivilDay>().value();
     return os << date;
   }
-  if (v.kind_case() == google::bigtable::v2::Value::kArrayValue) {
+  if (t.kind_case() == google::bigtable::v2::Type::kArrayType) {
     char const* delimiter = "";
     os << '[';
     for (auto&& val : v.array_value().values()) {
@@ -178,15 +234,30 @@ std::ostream& StreamHelper(std::ostream& os,  // NOLINT(misc-no-recursion)
       delimiter = ", ";
     }
     return os << ']';
-    return os;
+  }
+  if (t.kind_case() == google::bigtable::v2::Type::kStructType) {
+    char const* delimiter = "";
+    os << '(';
+    for (int i = 0; i < v.array_value().values_size(); ++i) {
+      os << delimiter;
+      if (!t.struct_type().fields(i).field_name().empty()) {
+        os << '"';
+        EscapeQuotes(os, t.struct_type().fields(i).field_name());
+        os << '"' << ": ";
+      }
+      StreamHelper(os, v.array_value().values(i),
+                   t.struct_type().fields(i).type(), StreamMode::kAggregate);
+      delimiter = ", ";
+    }
+    return os << ')';
   }
   // this should include type name
-  return os << "Error: unknown value type code ";
+  return os << "Error: unknown value type code " << t.kind_case();
 }
 }  // namespace
 
 bool operator==(Value const& a, Value const& b) {
-  return Equal(a.type_, a.value_, b.type_, b.value_);
+  return bigtable::Equal(a.type_, a.value_, b.type_, b.value_);
 }
 
 std::ostream& operator<<(std::ostream& os, Value const& v) {
diff --git a/google/cloud/bigtable/value.h b/google/cloud/bigtable/value.h
index 2db48ef685353..b8d9ba6ba489a 100644
--- a/google/cloud/bigtable/value.h
+++ b/google/cloud/bigtable/value.h
@@ -14,6 +14,7 @@
 #ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_BIGTABLE_VALUE_H
 #define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_BIGTABLE_VALUE_H
 
+#include "google/cloud/bigtable/internal/tuple_utils.h"
 #include "google/cloud/bigtable/version.h"
 #include "google/cloud/internal/make_status.h"
 #include "google/cloud/status_or.h"
@@ -48,6 +49,7 @@ static bool validate_float_value(double v) {
 static bool ValidateFloatValue(double v) { return validate_float_value(v); }
 
 static bool ValidateFloatValue(float v) { return validate_float_value(v); }
+
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace bigtable_internal
 
@@ -75,6 +77,7 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
  * TIMESTAMP    | `google::cloud::bigtable::Timestamp`
  * DATE         | `absl::CivilDay`
  * ARRAY        | `std::vector<T>`  // [1]
+ * STRUCT       | `std::tuple<Ts...>`
  *
  * [1] The type `T` may be any of the other supported types, except for
  *     ARRAY/`std::vector`.
@@ -100,6 +103,30 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
  * assert(vec == copy);
  * @endcode
  *
+ * @par Bigtable Structs
+ *
+ * Bigtable structs are represented in C++ as instances of `std::tuple` holding
+ * zero or more of the allowed Bigtable types, such as `bool`, `std::int64_t`,
+ * `std::vector`, and even other `std::tuple` objects. Each tuple element
+ * corresponds to a single field in a Bigtable STRUCT.
+ *
+ * Bigtable STRUCT fields may optionally contain a string indicating the field's
+ * name. Fields names may be empty, unique, or repeated. A named field may be
+ * specified as a tuple element of type `std::pair<std::string, T>`, where the
+ * pair's `.first` member indicates the field's name, and the `.second` member
+ * is any valid Bigtable type `T`.
+ *
+ * @code
+ * using Struct = std::tuple<bool, std::pair<std::string, std::int64_t>>;
+ * Struct s  = {true, {"Foo", 42}};
+ * bigtable::Value v(s);
+ * assert(s == *v.get<Struct>());
+ * @endcode
+ *
+ * @note While a STRUCT's (optional) field names are not part of its C++ type,
+ *   they are part of its Bigtable STRUCT type. Array's (i.e., `std::vector`)
+ *   must contain a single element type, therefore it is an error to construct
+ *   a `std::vector` of `std::tuple` objects with differently named fields.
  */
 class Value {
  public:
@@ -176,6 +203,17 @@ class Value {
                   "vector of vector not allowed. See value.h documentation.");
   }
 
+  /**
+   * Constructs an instance from a Bigtable STRUCT with a type and values
+   * matching the given `std::tuple`.
+   *
+   * Any STRUCT field may optionally have a name, which is specified as
+   * `std::pair<std::string, T>`.
+   */
+  template <typename... Ts>
+  explicit Value(std::tuple<Ts...> tup)
+      : Value(PrivateConstructor{}, std::move(tup)) {}
+
   // Copy and move.
   Value(Value const&) = default;
   Value(Value&&) = default;
@@ -264,6 +302,32 @@ class Value {
     return type.has_array_type() &&
            TypeProtoIs(T{}, type.array_type().element_type());
   }
+  template <typename... Ts>
+  static bool TypeProtoIs(std::tuple<Ts...> const& tup,
+                          google::bigtable::v2::Type const& type) {
+    bool ok = type.has_struct_type();
+    ok = ok && type.struct_type().fields().size() == sizeof...(Ts);
+    bigtable_internal::ForEach(tup, IsStructTypeProto{ok, 0},
+                               type.struct_type());
+    return ok;
+  }
+
+  // A functor to be used with internal::ForEach to check if a StructType proto
+  // matches the types in a std::tuple.
+  struct IsStructTypeProto {
+    bool& ok;
+    int field;
+    template <typename T>
+    void operator()(T const&, google::bigtable::v2::Type_Struct const& type) {
+      ok = ok && TypeProtoIs(T{}, type.fields(field).type());
+      ++field;
+    }
+    template <typename T>
+    void operator()(std::pair<std::string, T> const&,
+                    google::bigtable::v2::Type_Struct const& type) {
+      operator()(T{}, type);
+    }
+  };
 
   // Tag-dispatch overloads to convert a C++ type to a `Type` protobuf. The
   // argument type is the tag, the argument value is ignored.
@@ -297,6 +361,35 @@ class Value {
     }
     return t;
   }
+  template <typename... Ts>
+  static google::bigtable::v2::Type MakeTypeProto(
+      std::tuple<Ts...> const& tup) {
+    google::bigtable::v2::Type t;
+    t.set_allocated_struct_type(
+        std::move(new google::bigtable::v2::Type_Struct()));
+    bigtable_internal::ForEach(tup, AddStructTypes{}, *t.mutable_struct_type());
+    return t;
+  }
+
+  // A functor to be used with internal::ForEach to add type protos for all the
+  // elements of a tuple.
+  struct AddStructTypes {
+    template <typename T>
+    void operator()(T const& t,
+                    google::bigtable::v2::Type_Struct& struct_type) const {
+      auto* field = struct_type.add_fields();
+      *field->mutable_type() = MakeTypeProto(t);
+    }
+    template <
+        typename S, typename T,
+        std::enable_if_t<std::is_convertible<S, std::string>::value, int> = 0>
+    void operator()(std::pair<S, T> const& p,
+                    google::bigtable::v2::Type_Struct& struct_type) const {
+      auto* field = struct_type.add_fields();
+      field->set_allocated_field_name(std::move(new std::string(p.first)));
+      *field->mutable_type() = MakeTypeProto(p.second);
+    }
+  };
 
   // Encodes the argument as a protobuf according to the rules described in
   // https://github.com/googleapis/googleapis/blob/master/google/bigtable/v2/type.proto
@@ -327,6 +420,29 @@ class Value {
     }
     return v;
   }
+  template <typename... Ts>
+  static google::bigtable::v2::Value MakeValueProto(std::tuple<Ts...> tup) {
+    google::bigtable::v2::Value v;
+    bigtable_internal::ForEach(tup, AddStructValues{},
+                               *v.mutable_array_value());
+    return v;
+  }
+
+  // A functor to be used with internal::ForEach to add Value protos for all
+  // the elements of a tuple.
+  struct AddStructValues {
+    template <typename T>
+    void operator()(T& t, google::bigtable::v2::ArrayValue& list_value) const {
+      *list_value.add_values() = MakeValueProto(std::move(t));
+    }
+    template <
+        typename S, typename T,
+        std::enable_if_t<std::is_convertible<S, std::string>::value, int> = 0>
+    void operator()(std::pair<S, T> p,
+                    google::bigtable::v2::ArrayValue& list_value) const {
+      *list_value.add_values() = MakeValueProto(std::move(p.second));
+    }
+  };
 
   // Tag-dispatch overloads to extract a C++ value from a `Value` protobuf. The
   // first argument type is the tag, its value is ignored.
@@ -368,12 +484,12 @@ class Value {
   template <typename T, typename V>
   static StatusOr<std::vector<T>> GetValue(
       std::vector<T> const&, V&& pv, google::bigtable::v2::Type const& pt) {
-    if (pv.kind_case() != google::bigtable::v2::Value::kArrayValue) {
+    if (!pt.has_array_type() || !pv.has_array_value()) {
       return internal::UnknownError("missing ARRAY", GCP_ERROR_INFO());
     }
     std::vector<T> v;
     for (int i = 0; i < pv.array_value().values().size(); ++i) {
-      auto&& e = GetProtoListValueElement(std::forward<V>(pv), i);
+      auto&& e = GetProtoValueArrayElement(std::forward<V>(pv), i);
       using ET = decltype(e);
       auto value =
           GetValue(T{}, std::forward<ET>(e), pt.array_type().element_type());
@@ -382,16 +498,67 @@ class Value {
     }
     return v;
   }
+  template <typename V, typename... Ts>
+  static StatusOr<std::tuple<Ts...>> GetValue(
+      std::tuple<Ts...> const&, V&& pv, google::bigtable::v2::Type const& pt) {
+    if (!pt.has_struct_type() || !pv.has_array_value()) {
+      return internal::UnknownError("missing STRUCT", GCP_ERROR_INFO());
+    }
+    std::tuple<Ts...> tup;
+    Status status;  // OK
+    ExtractTupleValues<V> f{status, 0, std::forward<V>(pv), pt};
+    bigtable_internal::ForEach(tup, f);
+    if (!status.ok()) return status;
+    return tup;
+  }
+
+  // A functor to be used with internal::ForEach to extract C++ types from a
+  // bigtable::v2::Value proto and with array value store then in a tuple.
+  template <typename V>
+  struct ExtractTupleValues {
+    Status& status;
+    int i;
+    V&& pv;
+    google::bigtable::v2::Type const& type;
+    template <typename T>
+    void operator()(T& t) {
+      auto&& e = GetProtoValueArrayElement(std::forward<V>(pv), i);
+      auto et = type.struct_type().fields(i).type();
+      using ET = decltype(e);
+      auto value = GetValue(T{}, std::forward<ET>(e), et);
+      ++i;
+      if (!value) {
+        status = std::move(value).status();
+      } else {
+        t = *std::move(value);
+      }
+    }
+    template <typename T>
+    void operator()(std::pair<std::string, T>& p) {
+      p.first = type.struct_type().fields(i).field_name();
+      auto&& e = GetProtoValueArrayElement(std::forward<V>(pv), i);
+      auto et = type.struct_type().fields(i).type();
+      using ET = decltype(e);
+      auto value = GetValue(T{}, std::forward<ET>(e), et);
+      ++i;
+      if (!value) {
+        status = std::move(value).status();
+      } else {
+        p.second = *std::move(value);
+      }
+    }
+  };
 
   // Protocol buffers are not friendly to generic programming, because they use
   // different syntax and different names for mutable and non-mutable
-  // functions. To make GetValue(vector<T>, ...) (above) work, we need split
-  // the different protobuf syntaxes into overloaded functions.
-  static google::bigtable::v2::Value const& GetProtoListValueElement(
+  // functions. To make GetValue(vector<T>, ...) or GetValue(tuple<K,V>, ...)
+  // (above) work, we need split the different protobuf syntaxes into
+  // overloaded functions.
+  static google::bigtable::v2::Value const& GetProtoValueArrayElement(
       google::bigtable::v2::Value const& pv, int pos) {
     return pv.array_value().values(pos);
   }
-  static google::bigtable::v2::Value&& GetProtoListValueElement(
+  static google::bigtable::v2::Value&& GetProtoValueArrayElement(
       google::bigtable::v2::Value&& pv, int pos) {
     return std::move(*pv.mutable_array_value()->mutable_values(pos));
   }
diff --git a/google/cloud/bigtable/value_test.cc b/google/cloud/bigtable/value_test.cc
index 7aeee5a66b5bc..d52fdbc615ccf 100644
--- a/google/cloud/bigtable/value_test.cc
+++ b/google/cloud/bigtable/value_test.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "google/cloud/bigtable/value.h"
+#include "google/cloud/bigtable/internal/tuple_utils.h"
 #include "google/cloud/internal/base64_transforms.h"
 #include "google/cloud/testing_util/is_proto_equal.h"
 #include "google/cloud/testing_util/status_matchers.h"
@@ -36,6 +37,7 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
 namespace {
 
 using ::google::cloud::testing_util::IsOk;
+using ::google::cloud::testing_util::IsOkAndHolds;
 using ::google::cloud::testing_util::IsProtoEqual;
 using ::testing::Not;
 
@@ -194,6 +196,31 @@ TEST(Value, BasicSemantics) {
   }
 }
 
+TEST(Value, ArrayValueBasedEquality) {
+  std::vector<Value> test_cases = {
+      Value(std::vector<double>{1.2, 3.4}),
+      Value(std::make_tuple(1.2, 3.4)),
+
+      // empty containers
+      Value(std::vector<double>()),
+      Value(std::make_tuple()),
+  };
+
+  for (size_t i = 0; i < test_cases.size(); i++) {
+    auto const& tc1 = test_cases[i];
+    for (size_t j = 0; j < test_cases.size(); j++) {
+      auto const& tc2 = test_cases[j];
+      // Compares tc1 to tc2, which ensures that different "kinds" of
+      // value are never equal.
+      if (i == j) {
+        EXPECT_EQ(tc1, tc2);
+        continue;
+      }
+      EXPECT_NE(tc1, tc2);
+    }
+  }
+}
+
 TEST(Value, Equality) {
   std::vector<std::pair<Value, Value>> test_cases = {
       {Value(false), Value(true)},
@@ -207,6 +234,8 @@ TEST(Value, Equality) {
       {Value(absl::CivilDay(1970, 1, 1)), Value(absl::CivilDay(2020, 3, 15))},
       {Value(std::vector<double>{1.2, 3.4}),
        Value(std::vector<double>{4.5, 6.7})},
+      {Value(std::make_tuple(false, 123, "foo")),
+       Value(std::make_tuple(true, 456, "bar"))},
   };
 
   for (auto const& tc : test_cases) {
@@ -320,6 +349,32 @@ TEST(Value, RvalueGetVectorString) {
   EXPECT_EQ(Type(data.size(), ""), *s);
 }
 
+// NOTE: This test relies on unspecified behavior about the moved-from state
+// of std::string. Specifically, this test relies on the fact that "large"
+// strings, when moved-from, end up empty. And we use this fact to verify that
+// spanner::Value::get<T>() correctly handles moves. If this test ever breaks
+// on some platform, we could probably delete this, unless we can think of a
+// better way to test move semantics.
+TEST(Value, RvalueGetStructString) {
+  using Type = std::tuple<std::pair<std::string, std::string>, std::string>;
+  Type data{std::make_pair("name", std::string(128, 'x')),
+            std::string(128, 'x')};
+  Value v(data);
+
+  auto s = v.get<Type>();
+  ASSERT_STATUS_OK(s);
+  EXPECT_EQ(data, *s);
+
+  s = std::move(v).get<Type>();
+  ASSERT_STATUS_OK(s);
+  EXPECT_EQ(data, *s);
+
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  s = MovedFromString<Type>(v);
+  ASSERT_STATUS_OK(s);
+  EXPECT_EQ(Type({"name", ""}, ""), *s);
+}
+
 TEST(Value, BytesRelationalOperators) {
   Bytes b1(std::string(1, '\x00'));
   Bytes b2(std::string(1, '\xff'));
@@ -438,6 +493,123 @@ TEST(Value, BigtableArray) {
   EXPECT_THAT(null_vf.get<ArrayInt64>(), Not(IsOk()));
 }
 
+TEST(Value, BigtableStruct) {
+  // Using declarations to shorten the tests, making them more readable.
+  using std::int64_t;
+  using std::make_pair;
+  using std::make_tuple;
+  using std::pair;
+  using std::string;
+  using std::tuple;
+
+  auto tup1 = make_tuple(false, int64_t{123});
+  using T1 = decltype(tup1);
+  Value v1(tup1);
+  ASSERT_STATUS_OK(v1.get<T1>());
+  EXPECT_EQ(tup1, *v1.get<T1>());
+  EXPECT_EQ(v1, v1);
+
+  // Verify we can extract tuple elements even if they're wrapped in a pair.
+  auto const pair0 = v1.get<tuple<pair<string, bool>, int64_t>>();
+  ASSERT_STATUS_OK(pair0);
+  EXPECT_EQ(std::get<0>(tup1), std::get<0>(*pair0).second);
+  EXPECT_EQ(std::get<1>(tup1), std::get<1>(*pair0));
+  auto const pair1 = v1.get<tuple<bool, pair<string, int64_t>>>();
+  ASSERT_STATUS_OK(pair1);
+  EXPECT_EQ(std::get<0>(tup1), std::get<0>(*pair1));
+  EXPECT_EQ(std::get<1>(tup1), std::get<1>(*pair1).second);
+  auto const pair01 =
+      v1.get<tuple<pair<string, bool>, pair<string, int64_t>>>();
+  ASSERT_STATUS_OK(pair01);
+  EXPECT_EQ(std::get<0>(tup1), std::get<0>(*pair01).second);
+  EXPECT_EQ(std::get<1>(tup1), std::get<1>(*pair01).second);
+
+  auto tup2 = make_tuple(false, make_pair(string("f2"), int64_t{123}));
+  using T2 = decltype(tup2);
+  Value v2(tup2);
+  EXPECT_THAT(v2.get<T2>(), IsOkAndHolds(tup2));
+  EXPECT_EQ(v2, v2);
+  EXPECT_NE(v2, v1);
+
+  // T1 is lacking field names, but otherwise the same as T2.
+  EXPECT_EQ(tup1, *v2.get<T1>());
+  EXPECT_NE(tup2, *v1.get<T2>());
+
+  auto tup3 = make_tuple(false, make_pair(string("Other"), int64_t{123}));
+  using T3 = decltype(tup3);
+  Value v3(tup3);
+  EXPECT_THAT(v3.get<T3>(), IsOkAndHolds(tup3));
+  EXPECT_EQ(v3, v3);
+  EXPECT_NE(v3, v2);
+  EXPECT_NE(v3, v1);
+
+  static_assert(std::is_same<T2, T3>::value, "Only diff is field name");
+
+  // v1 != v2, yet T2 works with v1 and vice versa
+  EXPECT_NE(v1, v2);
+  EXPECT_STATUS_OK(v1.get<T2>());
+  EXPECT_STATUS_OK(v2.get<T1>());
+
+  Value v_null(absl::optional<T1>{});
+  EXPECT_FALSE(v_null.get<absl::optional<T1>>()->has_value());
+  EXPECT_FALSE(v_null.get<absl::optional<T2>>()->has_value());
+
+  EXPECT_NE(v1, v_null);
+  EXPECT_NE(v2, v_null);
+
+  auto array_struct = std::vector<T3>{
+      T3{false, {"age", 1}},
+      T3{true, {"age", 2}},
+      T3{false, {"age", 3}},
+  };
+  using T4 = decltype(array_struct);
+  Value v4(array_struct);
+  EXPECT_STATUS_OK(v4.get<T4>());
+  EXPECT_THAT(v4.get<T3>(), Not(IsOk()));
+  EXPECT_THAT(v4.get<T2>(), Not(IsOk()));
+  EXPECT_THAT(v4.get<T1>(), Not(IsOk()));
+
+  EXPECT_THAT(v4.get<T4>(), IsOkAndHolds(array_struct));
+
+  auto empty = tuple<>{};
+  using T5 = decltype(empty);
+  Value v5(empty);
+  EXPECT_STATUS_OK(v5.get<T5>());
+  EXPECT_THAT(v5.get<T4>(), Not(IsOk()));
+  EXPECT_EQ(v5, v5);
+  EXPECT_NE(v5, v4);
+
+  EXPECT_THAT(v5.get<T5>(), IsOkAndHolds(empty));
+
+  auto deeply_nested = tuple<tuple<std::vector<absl::optional<bool>>>>{};
+  using T6 = decltype(deeply_nested);
+  Value v6(deeply_nested);
+  EXPECT_STATUS_OK(v6.get<T6>());
+  EXPECT_THAT(v6.get<T5>(), Not(IsOk()));
+  EXPECT_EQ(v6, v6);
+  EXPECT_NE(v6, v5);
+
+  EXPECT_THAT(v6.get<T6>(), IsOkAndHolds(deeply_nested));
+}
+
+TEST(Value, BigtableStructWithNull) {
+  auto v1 = Value(std::make_tuple(123, true));
+  auto v2 = Value(std::make_tuple(123, absl::optional<bool>{}));
+
+  auto protos1 = bigtable_internal::ToProto(v1);
+  auto protos2 = bigtable_internal::ToProto(v2);
+
+  // The type protos match for both values, but the value protos DO NOT match.
+  EXPECT_THAT(protos1.first, IsProtoEqual(protos2.first));
+  EXPECT_THAT(protos1.second, Not(IsProtoEqual(protos2.second)));
+
+  // Now verify that the second value has two fields and the second field
+  // contains a NULL value.
+  ASSERT_EQ(protos2.second.array_value().values_size(), 2);
+  ASSERT_EQ(protos2.second.array_value().values(1).kind_case(),
+            google::bigtable::v2::Value::KIND_NOT_SET);
+}
+
 TEST(Value, ProtoConversionBool) {
   for (auto b : {true, false}) {
     Value const v(b);
@@ -577,6 +749,29 @@ TEST(Value, ProtoConversionArray) {
   EXPECT_EQ(3, p.second.array_value().values(2).int_value());
 }
 
+TEST(Value, ProtoConversionStruct) {
+  auto data = std::make_tuple(3.14, std::make_pair("foo", 42));
+  Value const v(data);
+  auto const p = bigtable_internal::ToProto(v);
+  EXPECT_EQ(v, bigtable_internal::FromProto(p.first, p.second));
+  EXPECT_TRUE(p.first.has_struct_type());
+
+  Value const null_struct_value(
+      MakeNullValue<std::tuple<bool, std::int64_t>>());
+  auto const null_struct_proto = bigtable_internal::ToProto(null_struct_value);
+  EXPECT_TRUE(p.first.has_struct_type());
+
+  auto const& field0 = p.first.struct_type().fields(0);
+  EXPECT_EQ("", field0.field_name());
+  EXPECT_TRUE(field0.type().has_float64_type());
+  EXPECT_EQ(3.14, p.second.array_value().values(0).float_value());
+
+  auto const& field1 = p.first.struct_type().fields(1);
+  EXPECT_EQ("foo", field1.field_name());
+  EXPECT_TRUE(field1.type().has_int64_type());
+  EXPECT_EQ(42, p.second.array_value().values(1).int_value());
+}
+
 void SetNullProtoKind(Value& v) {
   auto p = bigtable_internal::ToProto(v);
   p.second.clear_kind();
@@ -608,6 +803,31 @@ void SetProtoKind(Value& v, char const* x) {
   v = bigtable_internal::FromProto(p.first, p.second);
 }
 
+void SetProtoKind(Value& v, std::vector<std::int64_t> const& x) {
+  auto p = bigtable_internal::ToProto(v);
+  auto list = *p.second.mutable_array_value();
+  for (auto&& e : x) {
+    google::bigtable::v2::Value el;
+    el.set_int_value(e);
+    *list.add_values() = el;
+  }
+  v = bigtable_internal::FromProto(p.first, p.second);
+}
+
+void SetProtoKind(Value& v, std::tuple<std::int64_t, std::int64_t> const& x) {
+  auto p = bigtable_internal::ToProto(v);
+  auto list = *p.second.mutable_array_value();
+  auto e = std::get<0>(x);
+  google::bigtable::v2::Value el;
+  el.set_int_value(e);
+  *list.add_values() = el;
+  el = google::bigtable::v2::Value();
+  e = std::get<1>(x);
+  el.set_int_value(e);
+  *list.add_values() = el;
+  v = bigtable_internal::FromProto(p.first, p.second);
+}
+
 void ClearProtoKind(Value& v) {
   auto p = bigtable_internal::ToProto(v);
   p.first.clear_kind();
@@ -631,6 +851,12 @@ TEST(Value, GetBadBool) {
 
   SetProtoKind(v, "hello");
   EXPECT_THAT(v.get<bool>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<bool>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<bool>(), Not(IsOk()));
 }
 
 TEST(Value, GetBadFloat64) {
@@ -658,6 +884,12 @@ TEST(Value, GetBadFloat64) {
 
   SetProtoKind(v, std::nan("NaN"));
   EXPECT_THAT(v.get<double>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<double>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<double>(), Not(IsOk()));
 }
 
 TEST(Value, GetBadFloat32) {
@@ -685,6 +917,12 @@ TEST(Value, GetBadFloat32) {
 
   SetProtoKind(v, std::nan("NaN"));
   EXPECT_THAT(v.get<float>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<float>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<float>(), Not(IsOk()));
 }
 
 TEST(Value, GetBadString) {
@@ -700,6 +938,12 @@ TEST(Value, GetBadString) {
 
   SetProtoKind(v, 0.0);
   EXPECT_THAT(v.get<std::string>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<std::string>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<std::string>(), Not(IsOk()));
 }
 
 TEST(Value, GetBadBytes) {
@@ -715,6 +959,12 @@ TEST(Value, GetBadBytes) {
 
   SetProtoKind(v, 0.0);
   EXPECT_THAT(v.get<Bytes>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<Bytes>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<Bytes>(), Not(IsOk()));
 }
 
 TEST(Value, GetBadTimestamp) {
@@ -733,6 +983,12 @@ TEST(Value, GetBadTimestamp) {
 
   SetProtoKind(v, "blah");
   EXPECT_THAT(v.get<Timestamp>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<Timestamp>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<Timestamp>(), Not(IsOk()));
 }
 
 TEST(Value, GetBadDate) {
@@ -751,6 +1007,12 @@ TEST(Value, GetBadDate) {
 
   SetProtoKind(v, "blah");
   EXPECT_THAT(v.get<absl::CivilDay>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<absl::CivilDay>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<absl::CivilDay>(), Not(IsOk()));
 }
 
 TEST(Value, GetBadOptional) {
@@ -763,6 +1025,12 @@ TEST(Value, GetBadOptional) {
 
   SetProtoKind(v, "blah");
   EXPECT_THAT(v.get<absl::optional<double>>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<absl::optional<double>>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<absl::optional<double>>(), Not(IsOk()));
 }
 
 TEST(Value, GetBadArray) {
@@ -781,6 +1049,36 @@ TEST(Value, GetBadArray) {
 
   SetProtoKind(v, "blah");
   EXPECT_THAT(v.get<std::vector<double>>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<std::vector<double>>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<std::vector<double>>(), Not(IsOk()));
+}
+
+TEST(Value, GetBadStruct) {
+  Value v(std::tuple<bool>{});
+  ClearProtoKind(v);
+  EXPECT_THAT(v.get<std::tuple<bool>>(), Not(IsOk()));
+
+  SetNullProtoKind(v);
+  EXPECT_THAT(v.get<std::tuple<bool>>(), Not(IsOk()));
+
+  SetProtoKind(v, true);
+  EXPECT_THAT(v.get<std::tuple<bool>>(), Not(IsOk()));
+
+  SetProtoKind(v, 0.0);
+  EXPECT_THAT(v.get<std::tuple<bool>>(), Not(IsOk()));
+
+  SetProtoKind(v, "blah");
+  EXPECT_THAT(v.get<std::tuple<bool>>(), Not(IsOk()));
+
+  SetProtoKind(v, std::vector<int64_t>{1, 2});
+  EXPECT_THAT(v.get<std::tuple<double>>(), Not(IsOk()));
+
+  SetProtoKind(v, std::make_tuple(1, 2));
+  EXPECT_THAT(v.get<std::tuple<double>>(), Not(IsOk()));
 }
 
 TEST(Value, OutputStream) {
@@ -794,6 +1092,9 @@ TEST(Value, OutputStream) {
   auto const float4 = [](std::ostream& os) -> std::ostream& {
     return os << std::showpoint << std::setprecision(4);
   };
+  auto const alphahex = [](std::ostream& os) -> std::ostream& {
+    return os << std::boolalpha << std::hex;
+  };
 
   struct TestCase {
     Value value;
@@ -863,7 +1164,47 @@ TEST(Value, OutputStream) {
       {MakeNullValue<std::vector<std::string>>(), "NULL", normal},
       {MakeNullValue<std::vector<Bytes>>(), "NULL", normal},
       {MakeNullValue<std::vector<absl::CivilDay>>(), "NULL", normal},
-      {MakeNullValue<std::vector<Timestamp>>(), "NULL", normal}};
+      {MakeNullValue<std::vector<Timestamp>>(), "NULL", normal},
+
+      // Tests structs
+      {Value(std::make_tuple(true, 123)), "(1, 123)", normal},
+      {Value(std::make_tuple(true, 123)), "(true, 7b)", alphahex},
+      {Value(std::make_tuple(std::make_pair("A", true),
+                             std::make_pair("B", 123))),
+       R"(("A": 1, "B": 123))", normal},
+      {Value(std::make_tuple(std::make_pair("A", true),
+                             std::make_pair("B", 123))),
+       R"(("A": true, "B": 7b))", alphahex},
+      {Value(std::make_tuple(
+           std::vector<std::int64_t>{10, 11, 12},
+           std::make_pair("B", std::vector<std::int64_t>{13, 14, 15}))),
+       R"(([10, 11, 12], "B": [13, 14, 15]))", normal},
+      {Value(std::make_tuple(
+           std::vector<std::int64_t>{10, 11, 12},
+           std::make_pair("B", std::vector<std::int64_t>{13, 14, 15}))),
+       R"(([a, b, c], "B": [d, e, f]))", hex},
+      {Value(std::make_tuple(std::make_tuple(
+           std::make_tuple(std::vector<std::int64_t>{10, 11, 12})))),
+       "((([10, 11, 12])))", normal},
+      {Value(std::make_tuple(std::make_tuple(
+           std::make_tuple(std::vector<std::int64_t>{10, 11, 12})))),
+       "((([a, b, c])))", hex},
+
+      // Tests struct with null members
+      {Value(std::make_tuple(absl::optional<bool>{})), "(NULL)", normal},
+      {Value(std::make_tuple(absl::optional<bool>{}, 123)), "(NULL, 123)",
+       normal},
+      {Value(std::make_tuple(absl::optional<bool>{}, 123)), "(NULL, 7b)", hex},
+      {Value(std::make_tuple(absl::optional<bool>{},
+                             absl::optional<std::int64_t>{})),
+       "(NULL, NULL)", normal},
+
+      // Tests null structs
+      {MakeNullValue<std::tuple<bool>>(), "NULL", normal},
+      {MakeNullValue<std::tuple<bool, std::int64_t>>(), "NULL", normal},
+      {MakeNullValue<std::tuple<float, std::string>>(), "NULL", normal},
+      {MakeNullValue<std::tuple<double, Bytes, Timestamp>>(), "NULL", normal},
+  };
 
   for (auto const& tc : test_case) {
     std::stringstream ss;