diff --git a/LICENSE.txt b/LICENSE.txt
index c2b0a996fed..06347f5445d 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1894,7 +1894,7 @@ This project includes code from the autobrew project.
 The following files are based on code from the autobrew project:
 * r/tools/autobrew
 * dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb
-* dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb 
+* dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb
 
 Copyright (c) 2019, Jeroen Ooms
 License: MIT
@@ -1976,6 +1976,20 @@ License: http://www.apache.org/licenses/LICENSE-2.0
 
 --------------------------------------------------------------------------------
 
+This project includes code from Velox.
+
+ * cpp/src/arrow/util/string_header.h
+
+is based on Velox's
+
+ * velox/type/StringView.h
+
+Copyright: Copyright (c) Facebook, Inc. and its affiliates.
+Home page: https://github.com/facebookincubator/velox
+License: http://www.apache.org/licenses/LICENSE-2.0
+
+--------------------------------------------------------------------------------
+
 The file cpp/src/arrow/vendored/musl/strptime.c has the following license
 
 Copyright © 2005-2020 Rich Felker, et al.
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 9e8ecb5ceb3..6b657738536 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -4593,6 +4593,7 @@ macro(build_opentelemetry)
        -DWITH_OTLP=ON
        -DWITH_OTLP_HTTP=ON
        -DWITH_OTLP_GRPC=OFF
+       -DWITH_STL=ON
        "-DProtobuf_INCLUDE_DIR=${OPENTELEMETRY_PROTOBUF_INCLUDE_DIR}"
        "-DProtobuf_LIBRARY=${OPENTELEMETRY_PROTOBUF_INCLUDE_DIR}"
        "-DProtobuf_PROTOC_EXECUTABLE=${OPENTELEMETRY_PROTOC_EXECUTABLE}")
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 00cf899349a..bd093edaad8 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -226,6 +226,7 @@ set(ARROW_SRCS
     util/ree_util.cc
     util/string.cc
     util/string_builder.cc
+    util/string_header.cc
     util/task_group.cc
     util/tdigest.cc
     util/thread_pool.cc
diff --git a/cpp/src/arrow/array/array_base.cc b/cpp/src/arrow/array/array_base.cc
index f7b8d7954e1..07c18998253 100644
--- a/cpp/src/arrow/array/array_base.cc
+++ b/cpp/src/arrow/array/array_base.cc
@@ -87,6 +87,10 @@ struct ScalarFromArraySlotImpl {
     return Finish(a.GetString(index_));
   }
 
+  Status Visit(const BinaryViewArray& a) {
+    return Finish(std::string{a.GetView(index_)});
+  }
+
   Status Visit(const FixedSizeBinaryArray& a) { return Finish(a.GetString(index_)); }
 
   Status Visit(const DayTimeIntervalArray& a) { return Finish(a.Value(index_)); }
diff --git a/cpp/src/arrow/array/array_binary.cc b/cpp/src/arrow/array/array_binary.cc
index 9466b5a48f9..7790c32ae3f 100644
--- a/cpp/src/arrow/array/array_binary.cc
+++ b/cpp/src/arrow/array/array_binary.cc
@@ -89,6 +89,28 @@ LargeStringArray::LargeStringArray(int64_t length,
 
 Status LargeStringArray::ValidateUTF8() const { return internal::ValidateUTF8(*data_); }
 
+BinaryViewArray::BinaryViewArray(const std::shared_ptr<ArrayData>& data) {
+  ARROW_CHECK_EQ(data->type->id(), Type::BINARY_VIEW);
+  SetData(data);
+}
+
+BinaryViewArray::BinaryViewArray(int64_t length, std::shared_ptr<Buffer> headers,
+                                 BufferVector char_buffers,
+                                 std::shared_ptr<Buffer> null_bitmap, int64_t null_count,
+                                 int64_t offset)
+    : PrimitiveArray(binary_view(), length, std::move(headers), std::move(null_bitmap),
+                     null_count, offset) {
+  data_->buffers.resize(char_buffers.size() + 2);
+  std::move(char_buffers.begin(), char_buffers.end(), data_->buffers.begin() + 2);
+}
+
+StringViewArray::StringViewArray(const std::shared_ptr<ArrayData>& data) {
+  ARROW_CHECK_EQ(data->type->id(), Type::STRING_VIEW);
+  SetData(data);
+}
+
+Status StringViewArray::ValidateUTF8() const { return internal::ValidateUTF8(*data_); }
+
 FixedSizeBinaryArray::FixedSizeBinaryArray(const std::shared_ptr<ArrayData>& data) {
   SetData(data);
 }
diff --git a/cpp/src/arrow/array/array_binary.h b/cpp/src/arrow/array/array_binary.h
index 7e58a96ff84..70e477b2741 100644
--- a/cpp/src/arrow/array/array_binary.h
+++ b/cpp/src/arrow/array/array_binary.h
@@ -22,6 +22,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -217,6 +218,84 @@ class ARROW_EXPORT LargeStringArray : public LargeBinaryArray {
   Status ValidateUTF8() const;
 };
 
+// ----------------------------------------------------------------------
+// BinaryView and StringView
+
+/// Concrete Array class for variable-size binary view data using the
+/// StringHeader struct to reference in-line or out-of-line string values
+class ARROW_EXPORT BinaryViewArray : public PrimitiveArray {
+ public:
+  using TypeClass = BinaryViewType;
+  using IteratorType = stl::ArrayIterator<BinaryViewArray>;
+
+  explicit BinaryViewArray(const std::shared_ptr<ArrayData>& data);
+
+  BinaryViewArray(int64_t length, std::shared_ptr<Buffer> headers,
+                  BufferVector char_buffers,
+                  std::shared_ptr<Buffer> null_bitmap = NULLPTR,
+                  int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+
+  const StringHeader* raw_values() const {
+    return reinterpret_cast<const StringHeader*>(raw_values_) + data_->offset;
+  }
+
+  // For API compatibility with BinaryArray etc.
+  std::string_view GetView(int64_t i) const {
+    const auto& s = raw_values()[i];
+    if (raw_pointers_) {
+      return std::string_view{s};
+    }
+    if (s.IsInline()) {
+      return {s.GetInlineData(), s.size()};
+    }
+    auto* char_buffers = data_->buffers.data() + 2;
+    return {char_buffers[s.GetBufferIndex()]->data_as<char>() + s.GetBufferOffset(),
+            s.size()};
+  }
+
+  std::optional<std::string_view> operator[](int64_t i) const {
+    return *IteratorType(*this, i);
+  }
+
+  IteratorType begin() const { return IteratorType(*this); }
+  IteratorType end() const { return IteratorType(*this, length()); }
+
+  bool has_raw_pointers() const { return raw_pointers_; }
+
+ protected:
+  using PrimitiveArray::PrimitiveArray;
+
+  void SetData(const std::shared_ptr<ArrayData>& data) {
+    PrimitiveArray::SetData(data);
+    raw_pointers_ =
+        internal::checked_cast<const BinaryViewType&>(*type()).has_raw_pointers();
+  }
+
+  bool raw_pointers_ = false;
+};
+
+/// Concrete Array class for variable-size string view (utf-8) data using
+/// StringHeader to reference in-line or out-of-line string values
+class ARROW_EXPORT StringViewArray : public BinaryViewArray {
+ public:
+  using TypeClass = StringViewType;
+
+  explicit StringViewArray(const std::shared_ptr<ArrayData>& data);
+
+  StringViewArray(int64_t length, std::shared_ptr<Buffer> data, BufferVector char_buffers,
+                  std::shared_ptr<Buffer> null_bitmap = NULLPTR,
+                  int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : BinaryViewArray(length, std::move(data), std::move(char_buffers),
+                        std::move(null_bitmap), null_count, offset) {
+    data_->type = utf8_view();
+  }
+
+  /// \brief Validate that this array contains only valid UTF8 entries
+  ///
+  /// This check is also implied by ValidateFull()
+  Status ValidateUTF8() const;
+};
+
 // ----------------------------------------------------------------------
 // Fixed width binary
 
diff --git a/cpp/src/arrow/array/array_binary_test.cc b/cpp/src/arrow/array/array_binary_test.cc
index 3bc9bb91a02..0453c9f9070 100644
--- a/cpp/src/arrow/array/array_binary_test.cc
+++ b/cpp/src/arrow/array/array_binary_test.cc
@@ -27,17 +27,21 @@
 
 #include "arrow/array.h"
 #include "arrow/array/builder_binary.h"
+#include "arrow/array/validate.h"
 #include "arrow/buffer.h"
 #include "arrow/memory_pool.h"
 #include "arrow/status.h"
 #include "arrow/testing/builder.h"
 #include "arrow/testing/gtest_util.h"
+#include "arrow/testing/matchers.h"
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bitmap_builders.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/key_value_metadata.h"
+#include "arrow/util/logging.h"
 #include "arrow/visit_data_inline.h"
 
 namespace arrow {
@@ -365,38 +369,211 @@ TYPED_TEST(TestStringArray, TestValidateOffsets) { this->TestValidateOffsets();
 
 TYPED_TEST(TestStringArray, TestValidateData) { this->TestValidateData(); }
 
+namespace string_header_helpers {
+
+StringHeader Inline(std::string_view chars) {
+  DCHECK(StringHeader::IsInline(chars.size()));
+  return StringHeader{chars};
+}
+
+StringHeader NotInline(std::string_view prefix, size_t length, size_t buffer_index,
+                       size_t offset) {
+  DCHECK_EQ(prefix.size(), 4);
+  DCHECK(!StringHeader::IsInline(length));
+  StringHeader s{prefix.data(), length};
+  s.SetIndexOffset(static_cast<uint32_t>(buffer_index), static_cast<uint32_t>(offset));
+  return s;
+}
+
+// Produce an Array of index/offset views from a std::vector of index/offset StringHeader
+Result<std::shared_ptr<StringViewArray>> MakeViewArray(
+    BufferVector char_buffers, const std::vector<StringHeader>& headers,
+    bool validate = true) {
+  auto length = static_cast<int64_t>(headers.size());
+  ARROW_ASSIGN_OR_RAISE(auto headers_buf, CopyBufferFromVector(headers));
+  auto arr = std::make_shared<StringViewArray>(length, std::move(headers_buf),
+                                               std::move(char_buffers));
+  if (validate) {
+    RETURN_NOT_OK(arr->ValidateFull());
+  }
+  return arr;
+}
+
+// Produce an Array of index/offset views from a std::vector of raw pointer StringHeader
+Result<std::shared_ptr<StringViewArray>> MakeViewArrayFromRaw(
+    BufferVector char_buffers, const std::vector<StringHeader>& raw,
+    bool validate = true) {
+  ARROW_ASSIGN_OR_RAISE(auto raw_buf, CopyBufferFromVector(raw));
+  StringViewArray raw_arr{static_cast<int64_t>(raw.size()), std::move(raw_buf),
+                          char_buffers};
+  raw_arr.data()->type = utf8_view(/*has_raw_pointers=*/true);
+
+  ARROW_ASSIGN_OR_RAISE(auto io_buf, AllocateBuffer(raw.size() * sizeof(StringHeader)));
+  RETURN_NOT_OK(internal::SwapStringHeaderPointers(
+      *raw_arr.data(), io_buf->mutable_data_as<StringHeader>()));
+
+  auto arr = std::make_shared<StringViewArray>(raw.size(), std::move(io_buf),
+                                               std::move(char_buffers));
+  if (validate) {
+    RETURN_NOT_OK(arr->ValidateFull());
+  }
+  return arr;
+}
+
+}  // namespace string_header_helpers
+
+TEST(StringViewArray, Validate) {
+  using string_header_helpers::Inline;
+  using string_header_helpers::MakeViewArray;
+  using string_header_helpers::NotInline;
+
+  // Since this is a test of validation, we need to be able to construct invalid arrays.
+  auto buffer_s = Buffer::FromString("supercalifragilistic(sp?)");
+  auto buffer_y = Buffer::FromString("yyyyyyyyyyyyyyyyyyyyyyyyy");
+
+  // empty array is valid
+  EXPECT_THAT(MakeViewArray({}, {}), Ok());
+
+  // empty array with some character buffers is valid
+  EXPECT_THAT(MakeViewArray({buffer_s, buffer_y}, {}), Ok());
+
+  // inline views need not have a corresponding buffer
+  EXPECT_THAT(MakeViewArray({}, {Inline("hello"), Inline("world"), Inline("inline me")}),
+              Ok());
+
+  // non-inline views are expected to reference only buffers managed by the array
+  EXPECT_THAT(
+      MakeViewArray({buffer_s, buffer_y}, {NotInline("supe", buffer_s->size(), 0, 0),
+                                           NotInline("yyyy", buffer_y->size(), 1, 0)}),
+      Ok());
+
+  // views may not reference char buffers not present in the array
+  EXPECT_THAT(MakeViewArray({}, {NotInline("supe", buffer_s->size(), 0, 0)}),
+              Raises(StatusCode::IndexError));
+  // ... or ranges which overflow the referenced char buffer
+  EXPECT_THAT(MakeViewArray({buffer_s}, {NotInline("supe", buffer_s->size() + 50, 0, 0)}),
+              Raises(StatusCode::IndexError));
+
+  // Additionally, the prefixes of non-inline views must match the character buffer
+  EXPECT_THAT(
+      MakeViewArray({buffer_s, buffer_y}, {NotInline("SUPE", buffer_s->size(), 0, 0),
+                                           NotInline("yyyy", buffer_y->size(), 1, 0)}),
+      Raises(StatusCode::Invalid));
+
+  // Invalid string views which are masked by a null bit do not cause validation to fail
+  auto invalid_but_masked = MakeViewArray({buffer_s},
+                                          {NotInline("SUPE", buffer_s->size(), 0, 0),
+                                           NotInline("yyyy", 50, 40, 30)},
+                                          /*validate=*/false)
+                                .ValueOrDie()
+                                ->data();
+  invalid_but_masked->null_count = 2;
+  invalid_but_masked->buffers[0] = *AllocateEmptyBitmap(2);
+  EXPECT_THAT(internal::ValidateArrayFull(*invalid_but_masked), Ok());
+
+  // overlapping views are allowed
+  EXPECT_THAT(MakeViewArray({buffer_s},
+                            {
+                                NotInline("supe", buffer_s->size(), 0, 0),
+                                NotInline("uper", buffer_s->size() - 1, 0, 1),
+                                NotInline("perc", buffer_s->size() - 2, 0, 2),
+                                NotInline("erca", buffer_s->size() - 3, 0, 3),
+                            }),
+              Ok());
+}
+
+TEST(StringViewArray, BinaryViewArrayFromRawPointerViews) {
+  using string_header_helpers::Inline;
+  using string_header_helpers::MakeViewArray;
+  using string_header_helpers::MakeViewArrayFromRaw;
+  using string_header_helpers::NotInline;
+
+  auto Roundtrip = [&](Result<std::shared_ptr<StringViewArray>> maybe_arr) {
+    ARROW_ASSIGN_OR_RAISE(auto arr, maybe_arr);
+
+    std::vector<StringHeader> raw(arr->length());
+    RETURN_NOT_OK(internal::SwapStringHeaderPointers(*arr->data(), raw.data()));
+    for (size_t i = 0; i < raw.size(); ++i) {
+      if (static_cast<std::string_view>(raw[i]) != arr->GetView(i)) {
+        return Status::Invalid("Produced incorrect raw pointer headers");
+      }
+    }
+
+    BufferVector char_buffers{arr->data()->buffers.begin() + 2,
+                              arr->data()->buffers.end()};
+    ARROW_ASSIGN_OR_RAISE(auto round_tripped,
+                          MakeViewArrayFromRaw(std::move(char_buffers), raw));
+
+    if (round_tripped->Equals(arr)) {
+      return Status::OK();
+    }
+    return Status::Invalid("not equal");
+  };
+
+  EXPECT_THAT(Roundtrip(MakeViewArray(
+                  {}, {Inline("hello"), Inline("world"), Inline("inline me")})),
+              Ok());
+
+  auto buffer_s = Buffer::FromString("supercalifragilistic(sp?)");
+  auto buffer_y = Buffer::FromString("yyyyyyyyyyyyyyyyyyyyyyyyy");
+
+  EXPECT_THAT(Roundtrip(MakeViewArray({buffer_s, buffer_y},
+                                      {
+                                          NotInline("supe", buffer_s->size(), 0, 0),
+                                          Inline("hello"),
+                                          NotInline("yyyy", buffer_y->size(), 1, 0),
+                                          Inline("world"),
+                                          NotInline("uper", buffer_s->size() - 1, 0, 1),
+                                      })),
+              Ok());
+
+  // use a larger number of buffers to test the binary search case
+  BufferVector buffers;
+  std::vector<StringHeader> headers;
+  for (size_t i = 0; i < 40; ++i) {
+    buffers.push_back(Buffer::FromString(std::string(13, 'c')));
+    headers.push_back(NotInline("cccc", 13, i, 0));
+  }
+  EXPECT_THAT(Roundtrip(MakeViewArray(buffers, headers)), Ok());
+
+  EXPECT_THAT(
+      MakeViewArrayFromRaw({buffer_s, buffer_y},
+                           {
+                               "not inlined, outside buffers",
+                           }),
+      Raises(StatusCode::IndexError,
+             testing::HasSubstr("pointed outside the provided character buffers")));
+}
+
 template <typename T>
 class TestUTF8Array : public ::testing::Test {
  public:
   using TypeClass = T;
-  using offset_type = typename TypeClass::offset_type;
   using ArrayType = typename TypeTraits<TypeClass>::ArrayType;
 
-  Status ValidateUTF8(int64_t length, std::vector<offset_type> offsets,
-                      std::string_view data, int64_t offset = 0) {
-    ArrayType arr(length, Buffer::Wrap(offsets), std::make_shared<Buffer>(data),
-                  /*null_bitmap=*/nullptr, /*null_count=*/0, offset);
-    return arr.ValidateUTF8();
+  Status ValidateUTF8(const Array& arr) {
+    return checked_cast<const ArrayType&>(arr).ValidateUTF8();
   }
 
-  Status ValidateUTF8(const std::string& json) {
-    auto ty = TypeTraits<T>::type_singleton();
-    auto arr = ArrayFromJSON(ty, json);
-    return checked_cast<const ArrayType&>(*arr).ValidateUTF8();
+  Status ValidateUTF8(std::vector<std::string> values) {
+    std::shared_ptr<Array> arr;
+    ArrayFromVector<T, std::string>(values, &arr);
+    return ValidateUTF8(*arr);
   }
 
   void TestValidateUTF8() {
-    ASSERT_OK(ValidateUTF8(R"(["Voix", "ambiguë", "d’un", "cœur"])"));
-    ASSERT_OK(ValidateUTF8(1, {0, 4}, "\xf4\x8f\xbf\xbf"));  // \U0010ffff
+    ASSERT_OK(ValidateUTF8(*ArrayFromJSON(TypeTraits<T>::type_singleton(),
+                                          R"(["Voix", "ambiguë", "d’un", "cœur"])")));
+    ASSERT_OK(ValidateUTF8({"\xf4\x8f\xbf\xbf"}));  // \U0010ffff
 
-    ASSERT_RAISES(Invalid, ValidateUTF8(1, {0, 1}, "\xf4"));
+    ASSERT_RAISES(Invalid, ValidateUTF8({"\xf4"}));
 
     // More tests in TestValidateData() above
     // (ValidateFull() calls ValidateUTF8() internally)
   }
 };
 
-TYPED_TEST_SUITE(TestUTF8Array, StringArrowTypes);
+TYPED_TEST_SUITE(TestUTF8Array, StringOrStringViewArrowTypes);
 
 TYPED_TEST(TestUTF8Array, TestValidateUTF8) { this->TestValidateUTF8(); }
 
@@ -883,11 +1060,15 @@ class TestBaseBinaryDataVisitor : public ::testing::Test {
   void SetUp() override { type_ = TypeTraits<TypeClass>::type_singleton(); }
 
   void TestBasics() {
-    auto array = ArrayFromJSON(type_, R"(["foo", null, "bar"])");
+    auto array = ArrayFromJSON(
+        type_,
+        R"(["foo", null, "bar", "inline_me", "allocate_me_aaaaa", "allocate_me_bbbb"])");
     BinaryAppender appender;
     ArraySpanVisitor<TypeClass> visitor;
     ASSERT_OK(visitor.Visit(*array->data(), &appender));
-    ASSERT_THAT(appender.data, ::testing::ElementsAreArray({"foo", "(null)", "bar"}));
+    ASSERT_THAT(appender.data,
+                ::testing::ElementsAreArray({"foo", "(null)", "bar", "inline_me",
+                                             "allocate_me_aaaaa", "allocate_me_bbbb"}));
     ARROW_UNUSED(visitor);  // Workaround weird MSVC warning
   }
 
@@ -904,7 +1085,7 @@ class TestBaseBinaryDataVisitor : public ::testing::Test {
   std::shared_ptr<DataType> type_;
 };
 
-TYPED_TEST_SUITE(TestBaseBinaryDataVisitor, BaseBinaryArrowTypes);
+TYPED_TEST_SUITE(TestBaseBinaryDataVisitor, BaseBinaryOrBinaryViewLikeArrowTypes);
 
 TYPED_TEST(TestBaseBinaryDataVisitor, Basics) { this->TestBasics(); }
 
diff --git a/cpp/src/arrow/array/array_test.cc b/cpp/src/arrow/array/array_test.cc
index 602a468fafb..ff87e0b8ddb 100644
--- a/cpp/src/arrow/array/array_test.cc
+++ b/cpp/src/arrow/array/array_test.cc
@@ -594,12 +594,14 @@ static ScalarVector GetScalars() {
       std::make_shared<DurationScalar>(60, duration(TimeUnit::SECOND)),
       std::make_shared<BinaryScalar>(hello),
       std::make_shared<LargeBinaryScalar>(hello),
+      std::make_shared<BinaryViewScalar>(hello),
       std::make_shared<FixedSizeBinaryScalar>(
           hello, fixed_size_binary(static_cast<int32_t>(hello->size()))),
       std::make_shared<Decimal128Scalar>(Decimal128(10), decimal(16, 4)),
       std::make_shared<Decimal256Scalar>(Decimal256(10), decimal(76, 38)),
       std::make_shared<StringScalar>(hello),
       std::make_shared<LargeStringScalar>(hello),
+      std::make_shared<StringViewScalar>(hello),
       std::make_shared<ListScalar>(ArrayFromJSON(int8(), "[1, 2, 3]")),
       ScalarFromJSON(map(int8(), utf8()), R"([[1, "foo"], [2, "bar"]])"),
       std::make_shared<LargeListScalar>(ArrayFromJSON(int8(), "[1, 1, 2, 2, 3, 3]")),
@@ -646,7 +648,7 @@ TEST_F(TestArray, TestMakeArrayFromScalar) {
       ASSERT_EQ(array->null_count(), 0);
 
       // test case for ARROW-13321
-      for (int64_t i : std::vector<int64_t>{0, length / 2, length - 1}) {
+      for (int64_t i : {int64_t{0}, length / 2, length - 1}) {
         ASSERT_OK_AND_ASSIGN(auto s, array->GetScalar(i));
         AssertScalarsEqual(*s, *scalar, /*verbose=*/true);
       }
@@ -720,32 +722,32 @@ TEST_F(TestArray, TestMakeEmptyArray) {
   FieldVector union_fields2({field("a", null()), field("b", list(large_utf8()))});
   std::vector<int8_t> union_type_codes{7, 42};
 
-  std::shared_ptr<DataType> types[] = {null(),
-                                       boolean(),
-                                       int8(),
-                                       uint16(),
-                                       int32(),
-                                       uint64(),
-                                       float64(),
-                                       binary(),
-                                       large_binary(),
-                                       fixed_size_binary(3),
-                                       decimal(16, 4),
-                                       utf8(),
-                                       large_utf8(),
-                                       list(utf8()),
-                                       list(int64()),
-                                       large_list(large_utf8()),
-                                       fixed_size_list(utf8(), 3),
-                                       fixed_size_list(int64(), 4),
-                                       dictionary(int32(), utf8()),
-                                       struct_({field("a", utf8()), field("b", int32())}),
-                                       sparse_union(union_fields1, union_type_codes),
-                                       sparse_union(union_fields2, union_type_codes),
-                                       dense_union(union_fields1, union_type_codes),
-                                       dense_union(union_fields2, union_type_codes)};
-
-  for (auto type : types) {
+  for (auto type : {null(),
+                    boolean(),
+                    int8(),
+                    uint16(),
+                    int32(),
+                    uint64(),
+                    float64(),
+                    binary(),
+                    binary_view(),
+                    large_binary(),
+                    fixed_size_binary(3),
+                    decimal(16, 4),
+                    utf8(),
+                    utf8_view(),
+                    large_utf8(),
+                    list(utf8()),
+                    list(int64()),
+                    large_list(large_utf8()),
+                    fixed_size_list(utf8(), 3),
+                    fixed_size_list(int64(), 4),
+                    dictionary(int32(), utf8()),
+                    struct_({field("a", utf8()), field("b", int32())}),
+                    sparse_union(union_fields1, union_type_codes),
+                    sparse_union(union_fields2, union_type_codes),
+                    dense_union(union_fields1, union_type_codes),
+                    dense_union(union_fields2, union_type_codes)}) {
     ARROW_SCOPED_TRACE("type = ", type->ToString());
     ASSERT_OK_AND_ASSIGN(auto array, MakeEmptyArray(type));
     ASSERT_OK(array->ValidateFull());
diff --git a/cpp/src/arrow/array/array_view_test.cc b/cpp/src/arrow/array/array_view_test.cc
index 07dc3014e40..97110ea97f3 100644
--- a/cpp/src/arrow/array/array_view_test.cc
+++ b/cpp/src/arrow/array/array_view_test.cc
@@ -126,6 +126,38 @@ TEST(TestArrayView, StringAsBinary) {
   CheckView(expected, arr);
 }
 
+TEST(TestArrayView, StringViewAsBinaryView) {
+  for (auto json : {
+           R"(["foox", "barz", null])",
+           R"(["foox", "barz_not_inlined", null])",
+       }) {
+    auto arr = ArrayFromJSON(utf8_view(), json);
+    auto expected = ArrayFromJSON(binary_view(), json);
+    CheckView(arr, expected);
+    CheckView(expected, arr);
+  }
+}
+
+TEST(TestArrayView, StringViewAsBinaryViewInStruct) {
+  auto padl = ArrayFromJSON(list(int16()), "[[0, -1], [], [42]]");
+  auto padr = ArrayFromJSON(utf8(), R"(["foox", "barz", null])");
+
+  for (auto json : {
+           R"(["foox", "barz", null])",
+           R"(["foox", "barz_not_inlined", null])",
+       }) {
+    auto arr =
+        StructArray::Make({padl, ArrayFromJSON(utf8_view(), json), padr}, {"", "", ""})
+            .ValueOrDie();
+    auto expected =
+        StructArray::Make({padl, ArrayFromJSON(binary_view(), json), padr}, {"", "", ""})
+            .ValueOrDie();
+
+    CheckView(arr, expected);
+    CheckView(expected, arr);
+  }
+}
+
 TEST(TestArrayView, PrimitiveWrongSize) {
   auto arr = ArrayFromJSON(int16(), "[0, -1, 42]");
   CheckViewFails(arr, int8());
diff --git a/cpp/src/arrow/array/builder_base.cc b/cpp/src/arrow/array/builder_base.cc
index 70da1fbb296..9cdfb0b4681 100644
--- a/cpp/src/arrow/array/builder_base.cc
+++ b/cpp/src/arrow/array/builder_base.cc
@@ -104,10 +104,7 @@ namespace {
 template <typename ConstIterator>
 struct AppendScalarImpl {
   template <typename T>
-  enable_if_t<has_c_type<T>::value || is_decimal_type<T>::value ||
-                  is_fixed_size_binary_type<T>::value,
-              Status>
-  Visit(const T&) {
+  Status HandleFixedWidth(const T&) {
     auto builder = checked_cast<typename TypeTraits<T>::BuilderType*>(builder_);
     RETURN_NOT_OK(builder->Reserve(n_repeats_ * (scalars_end_ - scalars_begin_)));
 
@@ -125,7 +122,17 @@ struct AppendScalarImpl {
   }
 
   template <typename T>
-  enable_if_base_binary<T, Status> Visit(const T&) {
+  enable_if_t<has_c_type<T>::value, Status> Visit(const T& t) {
+    return HandleFixedWidth(t);
+  }
+
+  Status Visit(const FixedSizeBinaryType& t) { return HandleFixedWidth(t); }
+  Status Visit(const Decimal128Type& t) { return HandleFixedWidth(t); }
+  Status Visit(const Decimal256Type& t) { return HandleFixedWidth(t); }
+
+  template <typename T>
+  enable_if_t<is_binary_like_type<T>::value || is_string_like_type<T>::value, Status>
+  Visit(const T&) {
     int64_t data_size = 0;
     for (auto it = scalars_begin_; it != scalars_end_; ++it) {
       const auto& scalar = checked_cast<const typename TypeTraits<T>::ScalarType&>(*it);
diff --git a/cpp/src/arrow/array/builder_binary.cc b/cpp/src/arrow/array/builder_binary.cc
index 571f450aab9..b5ed7187edb 100644
--- a/cpp/src/arrow/array/builder_binary.cc
+++ b/cpp/src/arrow/array/builder_binary.cc
@@ -40,6 +40,97 @@ namespace arrow {
 
 using internal::checked_cast;
 
+// ----------------------------------------------------------------------
+// Binary/StringView
+BinaryViewBuilder::BinaryViewBuilder(const std::shared_ptr<DataType>& type,
+                                     MemoryPool* pool)
+    : BinaryViewBuilder(pool) {
+  ARROW_CHECK(!checked_cast<const BinaryViewType&>(*type).has_raw_pointers());
+}
+
+Status BinaryViewBuilder::AppendValues(const std::vector<std::string>& values,
+                                       const uint8_t* valid_bytes) {
+  // We only need to allocate memory for the out-of-line strings
+  std::size_t out_of_line_total = std::accumulate(
+      values.begin(), values.end(), 0ULL, [](uint64_t sum, const std::string& str) {
+        size_t length = str.size();
+        return sum + (length > StringHeader::kInlineSize ? length : 0);
+      });
+  RETURN_NOT_OK(Reserve(values.size()));
+  RETURN_NOT_OK(ReserveData(out_of_line_total));
+
+  if (valid_bytes != nullptr) {
+    for (std::size_t i = 0; i < values.size(); ++i) {
+      if (valid_bytes[i]) {
+        UnsafeAppend(values[i]);
+      } else {
+        UnsafeAppendNull();
+      }
+    }
+  } else {
+    for (const auto& value : values) {
+      UnsafeAppend(value);
+    }
+  }
+  UnsafeAppendToBitmap(valid_bytes, values.size());
+  return Status::OK();
+}
+
+Status BinaryViewBuilder::AppendArraySlice(const ArraySpan& array, int64_t offset,
+                                           int64_t length) {
+  auto bitmap = array.GetValues<uint8_t>(0, 0);
+  auto values = array.GetValues<StringHeader>(1) + offset;
+
+  int64_t out_of_line_total = 0;
+  for (int64_t i = 0; i < length; i++) {
+    if (!values[i].IsInline()) {
+      out_of_line_total += static_cast<int64_t>(values[i].size());
+    }
+  }
+  RETURN_NOT_OK(Reserve(length));
+  RETURN_NOT_OK(ReserveData(out_of_line_total));
+  for (int64_t i = 0; i < length; i++) {
+    if (!bitmap || bit_util::GetBit(bitmap, array.offset + offset + i)) {
+      if (values[i].IsInline()) {
+        UnsafeAppend(values[i]);
+      } else {
+        UnsafeAppend(values[i].data(), values[i].size());
+      }
+    } else {
+      UnsafeAppendNull();
+    }
+  }
+  return Status::OK();
+}
+
+Status BinaryViewBuilder::FinishInternal(std::shared_ptr<ArrayData>* out) {
+  ARROW_ASSIGN_OR_RAISE(auto null_bitmap, null_bitmap_builder_.FinishWithLength(length_));
+  ARROW_ASSIGN_OR_RAISE(auto data, data_builder_.FinishWithLength(length_));
+  BufferVector buffers = {null_bitmap, data};
+  for (auto&& buffer : data_heap_builder_.Finish()) {
+    buffers.push_back(std::move(buffer));
+  }
+  *out = ArrayData::Make(type(), length_, std::move(buffers), null_count_);
+  capacity_ = length_ = null_count_ = 0;
+  Reset();
+  return Status::OK();
+}
+
+Status BinaryViewBuilder::ReserveData(int64_t length) {
+  if (ARROW_PREDICT_FALSE(length > ValueSizeLimit())) {
+    return Status::CapacityError(
+        "BinaryView or StringView elements cannot reference "
+        "strings larger than 4GB");
+  }
+  return data_heap_builder_.Reserve(length);
+}
+
+void BinaryViewBuilder::Reset() {
+  ArrayBuilder::Reset();
+  data_builder_.Reset();
+  data_heap_builder_.Reset();
+}
+
 // ----------------------------------------------------------------------
 // Fixed width binary
 
@@ -125,8 +216,8 @@ const uint8_t* FixedSizeBinaryBuilder::GetValue(int64_t i) const {
 
 std::string_view FixedSizeBinaryBuilder::GetView(int64_t i) const {
   const uint8_t* data_ptr = byte_builder_.data();
-  return std::string_view(reinterpret_cast<const char*>(data_ptr + i * byte_width_),
-                          byte_width_);
+  return {reinterpret_cast<const char*>(data_ptr + i * byte_width_),
+          static_cast<size_t>(byte_width_)};
 }
 
 // ----------------------------------------------------------------------
@@ -173,10 +264,10 @@ Status ChunkedStringBuilder::Finish(ArrayVector* out) {
   RETURN_NOT_OK(ChunkedBinaryBuilder::Finish(out));
 
   // Change data type to string/utf8
-  for (size_t i = 0; i < out->size(); ++i) {
-    std::shared_ptr<ArrayData> data = (*out)[i]->data();
+  for (auto& chunk : *out) {
+    std::shared_ptr<ArrayData> data = chunk->data()->Copy();
     data->type = ::arrow::utf8();
-    (*out)[i] = std::make_shared<StringArray>(data);
+    chunk = std::make_shared<StringArray>(std::move(data));
   }
   return Status::OK();
 }
diff --git a/cpp/src/arrow/array/builder_binary.h b/cpp/src/arrow/array/builder_binary.h
index b0c4fe2fc81..1eb906f91ed 100644
--- a/cpp/src/arrow/array/builder_binary.h
+++ b/cpp/src/arrow/array/builder_binary.h
@@ -204,10 +204,10 @@ class BaseBinaryBuilder
         }
       }
     } else {
-      for (std::size_t i = 0; i < values.size(); ++i) {
+      for (const auto& value : values) {
         UnsafeAppendNextOffset();
-        value_data_builder_.UnsafeAppend(
-            reinterpret_cast<const uint8_t*>(values[i].data()), values[i].size());
+        value_data_builder_.UnsafeAppend(reinterpret_cast<const uint8_t*>(value.data()),
+                                         value.size());
       }
     }
 
@@ -463,6 +463,249 @@ class ARROW_EXPORT LargeStringBuilder : public LargeBinaryBuilder {
   std::shared_ptr<DataType> type() const override { return large_utf8(); }
 };
 
+// ----------------------------------------------------------------------
+// BinaryViewBuilder, StringViewBuilder
+//
+// These builders do not support building raw pointer string view arrays.
+
+namespace internal {
+
+// Because we construct StringHeader objects incrementally, resizing buffers is
+// not an option as memory addresses for out-of-line strings will change. Thus,
+// we allocate medium-sized memory chunks and accumulate data in those, which
+// may result in some waste if there are many large-ish strings. If a string
+// comes along that does not fit into a block, we allocate a new block and
+// write into that.
+//
+// Later we can implement optimizations to continuing filling underfull blocks
+// after encountering a large string that required allocating a new block.
+class ARROW_EXPORT StringHeapBuilder {
+ public:
+  static constexpr int64_t kDefaultBlocksize = 1 << 20;  // 1MB
+
+  StringHeapBuilder(MemoryPool* pool, int64_t alignment,
+                    int64_t blocksize = kDefaultBlocksize)
+      : pool_(pool), blocksize_(blocksize), alignment_(alignment) {}
+
+  void UnsafeAppend(StringHeader* raw_not_inlined) {
+    memcpy(current_out_buffer_, raw_not_inlined->GetRawPointer(),
+           raw_not_inlined->size());
+    raw_not_inlined->SetIndexOffset(static_cast<uint32_t>(blocks_.size() - 1),
+                                    current_offset_);
+    current_out_buffer_ += raw_not_inlined->size();
+    current_remaining_bytes_ -= raw_not_inlined->size();
+    current_offset_ += static_cast<uint32_t>(raw_not_inlined->size());
+  }
+
+  /// \brief Ensure that the indicated number of bytes can be appended via
+  /// UnsafeAppend operations without the need to allocate more memory
+  Status Reserve(int64_t num_bytes) {
+    if (num_bytes > current_remaining_bytes_) {
+      // Ensure the buffer is fully overwritten to avoid leaking uninitialized
+      // bytes from the allocator
+      if (current_remaining_bytes_ > 0) {
+        std::memset(current_out_buffer_, 0, current_remaining_bytes_);
+        blocks_.back() = SliceBuffer(blocks_.back(), 0,
+                                     blocks_.back()->size() - current_remaining_bytes_);
+      }
+      current_remaining_bytes_ = num_bytes > blocksize_ ? num_bytes : blocksize_;
+      ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Buffer> new_block,
+                            AllocateBuffer(current_remaining_bytes_, alignment_, pool_));
+      current_offset_ = 0;
+      current_out_buffer_ = new_block->mutable_data();
+      blocks_.emplace_back(std::move(new_block));
+    }
+    return Status::OK();
+  }
+
+  void Reset() {
+    current_offset_ = 0;
+    current_out_buffer_ = NULLPTR;
+    current_remaining_bytes_ = 0;
+    blocks_.clear();
+  }
+
+  int64_t current_remaining_bytes() const { return current_remaining_bytes_; }
+
+  std::vector<std::shared_ptr<Buffer>> Finish() {
+    current_offset_ = 0;
+    current_out_buffer_ = NULLPTR;
+    current_remaining_bytes_ = 0;
+    return std::move(blocks_);
+  }
+
+ private:
+  MemoryPool* pool_;
+  const int64_t blocksize_;
+  int64_t alignment_;
+  std::vector<std::shared_ptr<Buffer>> blocks_;
+
+  uint32_t current_offset_ = 0;
+  uint8_t* current_out_buffer_ = NULLPTR;
+  int64_t current_remaining_bytes_ = 0;
+};
+
+}  // namespace internal
+
+class ARROW_EXPORT BinaryViewBuilder : public ArrayBuilder {
+ public:
+  using TypeClass = BinaryViewType;
+
+  // this constructor provided for MakeBuilder compatibility
+  BinaryViewBuilder(const std::shared_ptr<DataType>&, MemoryPool* pool);
+
+  explicit BinaryViewBuilder(MemoryPool* pool = default_memory_pool(),
+                             int64_t alignment = kDefaultBufferAlignment)
+      : ArrayBuilder(pool, alignment),
+        data_builder_(pool, alignment),
+        data_heap_builder_(pool, alignment) {}
+
+  int64_t current_block_bytes_remaining() const {
+    return data_heap_builder_.current_remaining_bytes();
+  }
+
+  Status Append(const uint8_t* value, int64_t length) {
+    if (ARROW_PREDICT_FALSE(length > ValueSizeLimit())) {
+      return Status::CapacityError(
+          "BinaryView or StringView elements cannot reference "
+          "strings larger than 4GB");
+    }
+    if (!StringHeader::IsInline(length)) {
+      ARROW_RETURN_NOT_OK(ReserveData(length));
+    }
+    ARROW_RETURN_NOT_OK(Reserve(1));
+    UnsafeAppend(StringHeader(value, length));
+    return Status::OK();
+  }
+
+  Status Append(const char* value, int64_t length) {
+    return Append(reinterpret_cast<const uint8_t*>(value), length);
+  }
+
+  Status Append(std::string_view value) {
+    return Append(value.data(), static_cast<int64_t>(value.size()));
+  }
+
+  /// \brief Append without checking capacity
+  ///
+  /// Builder should have been presized using Reserve() and ReserveData(),
+  /// respectively, and the value must not be larger than 4GB
+  void UnsafeAppend(const uint8_t* value, int64_t length) {
+    UnsafeAppend(StringHeader(value, length));
+  }
+
+  void UnsafeAppend(const char* value, int64_t length) {
+    UnsafeAppend(reinterpret_cast<const uint8_t*>(value), length);
+  }
+
+  void UnsafeAppend(const std::string& value) {
+    UnsafeAppend(value.c_str(), static_cast<int64_t>(value.size()));
+  }
+
+  void UnsafeAppend(std::string_view value) {
+    UnsafeAppend(value.data(), static_cast<int64_t>(value.size()));
+  }
+
+  void UnsafeAppend(StringHeader value) {
+    UnsafeAppendToBitmap(true);
+    if (!value.IsInline()) {
+      // String is stored out-of-line
+      data_heap_builder_.UnsafeAppend(&value);
+    }
+    data_builder_.UnsafeAppend(value);
+  }
+
+  /// \brief Ensures there is enough allocated available capacity in the
+  /// out-of-line data heap to append the indicated number of bytes without
+  /// additional allocations
+  Status ReserveData(int64_t length);
+
+  Status AppendNulls(int64_t length) final {
+    ARROW_RETURN_NOT_OK(Reserve(length));
+    data_builder_.UnsafeAppend(length, StringHeader{});  // zero
+    UnsafeSetNull(length);
+    return Status::OK();
+  }
+
+  /// \brief Append a single null element
+  Status AppendNull() final {
+    ARROW_RETURN_NOT_OK(Reserve(1));
+    data_builder_.UnsafeAppend(StringHeader{});  // zero
+    UnsafeAppendToBitmap(false);
+    return Status::OK();
+  }
+
+  /// \brief Append a empty element (length-0 inline string)
+  Status AppendEmptyValue() final {
+    ARROW_RETURN_NOT_OK(Reserve(1));
+    data_builder_.UnsafeAppend(StringHeader{});  // zero
+    UnsafeAppendToBitmap(true);
+    return Status::OK();
+  }
+
+  /// \brief Append several empty elements
+  Status AppendEmptyValues(int64_t length) final {
+    ARROW_RETURN_NOT_OK(Reserve(length));
+    data_builder_.UnsafeAppend(length, StringHeader{});  // zero
+    UnsafeSetNotNull(length);
+    return Status::OK();
+  }
+
+  void UnsafeAppendNull() {
+    data_builder_.UnsafeAppend(StringHeader{});  // zero
+    UnsafeAppendToBitmap(false);
+  }
+
+  void UnsafeAppendEmptyValue() {
+    data_builder_.UnsafeAppend(StringHeader{});  // zero
+    UnsafeAppendToBitmap(true);
+  }
+
+  /// \brief Append a sequence of strings in one shot.
+  ///
+  /// \param[in] values a vector of strings
+  /// \param[in] valid_bytes an optional sequence of bytes where non-zero
+  /// indicates a valid (non-null) value
+  /// \return Status
+  Status AppendValues(const std::vector<std::string>& values,
+                      const uint8_t* valid_bytes = NULLPTR);
+
+  /// \brief Append a slice of a BinaryViewArray passed as an ArraySpan. Copies
+  /// the underlying out-of-line string memory to avoid memory lifetime issues
+  Status AppendArraySlice(const ArraySpan& array, int64_t offset,
+                          int64_t length) override;
+
+  void Reset() override;
+
+  Status Resize(int64_t capacity) override {
+    ARROW_RETURN_NOT_OK(CheckCapacity(capacity));
+    capacity = std::max(capacity, kMinBuilderCapacity);
+    ARROW_RETURN_NOT_OK(data_builder_.Resize(capacity));
+    return ArrayBuilder::Resize(capacity);
+  }
+
+  Status FinishInternal(std::shared_ptr<ArrayData>* out) override;
+
+  std::shared_ptr<DataType> type() const override { return binary_view(); }
+
+ protected:
+  static constexpr int64_t ValueSizeLimit() {
+    return std::numeric_limits<uint32_t>::max();
+  }
+
+  TypedBufferBuilder<StringHeader> data_builder_;
+
+  // Accumulates out-of-line data in fixed-size chunks which are then attached
+  // to the resulting ArrayData
+  internal::StringHeapBuilder data_heap_builder_;
+};
+
+class ARROW_EXPORT StringViewBuilder : public BinaryViewBuilder {
+ public:
+  using BinaryViewBuilder::BinaryViewBuilder;
+  std::shared_ptr<DataType> type() const override { return utf8_view(); }
+};
+
 // ----------------------------------------------------------------------
 // FixedSizeBinaryBuilder
 
@@ -498,7 +741,7 @@ class ARROW_EXPORT FixedSizeBinaryBuilder : public ArrayBuilder {
 
   Status Append(const Buffer& s) {
     ARROW_RETURN_NOT_OK(Reserve(1));
-    UnsafeAppend(std::string_view(s));
+    UnsafeAppend(s);
     return Status::OK();
   }
 
@@ -549,7 +792,7 @@ class ARROW_EXPORT FixedSizeBinaryBuilder : public ArrayBuilder {
     UnsafeAppend(reinterpret_cast<const uint8_t*>(value.data()));
   }
 
-  void UnsafeAppend(const Buffer& s) { UnsafeAppend(std::string_view(s)); }
+  void UnsafeAppend(const Buffer& s) { UnsafeAppend(std::string_view{s}); }
 
   void UnsafeAppend(const std::shared_ptr<Buffer>& s) { UnsafeAppend(*s); }
 
diff --git a/cpp/src/arrow/array/builder_dict.cc b/cpp/src/arrow/array/builder_dict.cc
index 061fb600412..c99a6faceeb 100644
--- a/cpp/src/arrow/array/builder_dict.cc
+++ b/cpp/src/arrow/array/builder_dict.cc
@@ -193,6 +193,12 @@ Status DictionaryMemoTable::GetOrInsert(const BinaryType*, std::string_view valu
   return impl_->GetOrInsert<BinaryType>(value, out);
 }
 
+Status DictionaryMemoTable::GetOrInsert(const BinaryViewType*, std::string_view value,
+                                        int32_t* out) {
+  // Create BinaryArray dictionary for now
+  return impl_->GetOrInsert<BinaryType>(value, out);
+}
+
 Status DictionaryMemoTable::GetOrInsert(const LargeBinaryType*, std::string_view value,
                                         int32_t* out) {
   return impl_->GetOrInsert<LargeBinaryType>(value, out);
diff --git a/cpp/src/arrow/array/builder_dict.h b/cpp/src/arrow/array/builder_dict.h
index cb0aaf30991..0cc82930a14 100644
--- a/cpp/src/arrow/array/builder_dict.h
+++ b/cpp/src/arrow/array/builder_dict.h
@@ -60,6 +60,12 @@ struct DictionaryValue<T, enable_if_base_binary<T>> {
                                 BinaryType, LargeBinaryType>::type;
 };
 
+template <typename T>
+struct DictionaryValue<T, enable_if_binary_view_like<T>> {
+  using type = std::string_view;
+  using PhysicalType = BinaryViewType;
+};
+
 template <typename T>
 struct DictionaryValue<T, enable_if_fixed_size_binary<T>> {
   using type = std::string_view;
@@ -115,6 +121,10 @@ class ARROW_EXPORT DictionaryMemoTable {
   Status GetOrInsert(const BinaryType*, std::string_view value, int32_t* out);
   Status GetOrInsert(const LargeBinaryType*, std::string_view value, int32_t* out);
 
+  // TODO: Consider working StringHeader throughout the hashing machinery to
+  // benefit from faster comparisons, reduced need to allocate memory
+  Status GetOrInsert(const BinaryViewType*, std::string_view value, int32_t* out);
+
   class DictionaryMemoTableImpl;
   std::unique_ptr<DictionaryMemoTableImpl> impl_;
 };
diff --git a/cpp/src/arrow/array/concatenate.cc b/cpp/src/arrow/array/concatenate.cc
index 65c82384369..6e863490480 100644
--- a/cpp/src/arrow/array/concatenate.cc
+++ b/cpp/src/arrow/array/concatenate.cc
@@ -229,6 +229,43 @@ class ConcatenateImpl {
     return ConcatenateBuffers(value_buffers, pool_).Value(&out_->buffers[2]);
   }
 
+  Status Visit(const BinaryViewType& type) {
+    out_->buffers.resize(2);
+
+    for (const auto& in_data : in_) {
+      auto begin = in_data->buffers.begin() + 2;
+      auto end = in_data->buffers.end();
+
+      for (auto it = begin; it != end; ++it) {
+        out_->buffers.push_back(*it);
+      }
+    }
+
+    ARROW_ASSIGN_OR_RAISE(auto header_buffers, Buffers(1, sizeof(StringHeader)));
+    ARROW_ASSIGN_OR_RAISE(auto header_buffer, ConcatenateBuffers(header_buffers, pool_));
+
+    if (!type.has_raw_pointers()) {
+      auto* s = header_buffer->mutable_data_as<StringHeader>();
+
+      size_t preceding_buffer_count = 0;
+
+      int64_t i = in_[0]->length;
+      for (size_t in_index = 1; in_index < in_.size(); ++in_index) {
+        preceding_buffer_count += in_[in_index - 1]->buffers.size() - 2;
+
+        for (int64_t end_i = i + in_[in_index]->length; i < end_i; ++i) {
+          if (s[i].IsInline()) continue;
+          auto buffer_index =
+              static_cast<uint32_t>(s[i].GetBufferIndex() + preceding_buffer_count);
+          s[i].SetIndexOffset(buffer_index, s[i].GetBufferOffset());
+        }
+      }
+    }
+
+    out_->buffers[1] = std::move(header_buffer);
+    return Status::OK();
+  }
+
   Status Visit(const ListType&) {
     std::vector<Range> value_ranges;
     ARROW_ASSIGN_OR_RAISE(auto index_buffers, Buffers(1, sizeof(int32_t)));
@@ -605,6 +642,10 @@ Result<std::shared_ptr<Array>> Concatenate(const ArrayVector& arrays, MemoryPool
     return Status::Invalid("Must pass at least one array");
   }
 
+  if (arrays.size() == 1) {
+    return arrays[0];
+  }
+
   // gather ArrayData of input arrays
   ArrayDataVector data(arrays.size());
   for (size_t i = 0; i < arrays.size(); ++i) {
diff --git a/cpp/src/arrow/array/concatenate_test.cc b/cpp/src/arrow/array/concatenate_test.cc
index 4c03fab731f..d9b0b7d235b 100644
--- a/cpp/src/arrow/array/concatenate_test.cc
+++ b/cpp/src/arrow/array/concatenate_test.cc
@@ -92,8 +92,14 @@ class ConcatenateTest : public ::testing::Test {
       for (auto null_probability : this->null_probabilities_) {
         std::shared_ptr<Array> array;
         factory(size, null_probability, &array);
+        ASSERT_OK(array->ValidateFull());
         auto expected = array->Slice(offsets.front(), offsets.back() - offsets.front());
+        ASSERT_OK(expected->ValidateFull());
         auto slices = this->Slices(array, offsets);
+        for (auto slice : slices) {
+          ASSERT_OK(slice->ValidateFull());
+        }
+        ASSERT_OK(expected->ValidateFull());
         ASSERT_OK_AND_ASSIGN(auto actual, Concatenate(slices));
         AssertArraysEqual(*expected, *actual);
         if (actual->data()->buffers[0]) {
@@ -155,6 +161,23 @@ TEST_F(ConcatenateTest, StringType) {
   });
 }
 
+TEST_F(ConcatenateTest, StringViewType) {
+  Check([this](int32_t size, double null_probability, std::shared_ptr<Array>* out) {
+    *out = rng_.StringView(size, /*min_length =*/0, /*max_length =*/15, null_probability);
+    ASSERT_OK((**out).ValidateFull());
+  });
+
+  Check([this](int32_t size, double null_probability, std::shared_ptr<Array>* out) {
+    *out = rng_.StringView(size, /*min_length =*/0, /*max_length =*/15, null_probability);
+    const ArrayData& io = *(*out)->data();
+    auto raw_buf = AllocateBuffer(io.buffers[1]->size()).ValueOrDie();
+    ABORT_NOT_OK(
+        internal::SwapStringHeaderPointers(io, raw_buf->mutable_data_as<StringHeader>()));
+    (*out)->data()->buffers[1] = std::move(raw_buf);
+    (*out)->data()->type = utf8_view(/*has_raw_pointers=*/true);
+  });
+}
+
 TEST_F(ConcatenateTest, LargeStringType) {
   Check([this](int32_t size, double null_probability, std::shared_ptr<Array>* out) {
     *out =
diff --git a/cpp/src/arrow/array/data.cc b/cpp/src/arrow/array/data.cc
index 8764e9c354c..1118b5d2220 100644
--- a/cpp/src/arrow/array/data.cc
+++ b/cpp/src/arrow/array/data.cc
@@ -186,7 +186,7 @@ void ArraySpan::SetMembers(const ArrayData& data) {
   }
   this->offset = data.offset;
 
-  for (int i = 0; i < static_cast<int>(data.buffers.size()); ++i) {
+  for (int i = 0; i < std::min(static_cast<int>(data.buffers.size()), 3); ++i) {
     const std::shared_ptr<Buffer>& buffer = data.buffers[i];
     // It is the invoker-of-kernels's responsibility to ensure that
     // const buffers are not written to accidentally.
@@ -199,7 +199,7 @@ void ArraySpan::SetMembers(const ArrayData& data) {
 
   Type::type type_id = this->type->id();
   if (type_id == Type::EXTENSION) {
-    const ExtensionType* ext_type = checked_cast<const ExtensionType*>(this->type);
+    auto* ext_type = checked_cast<const ExtensionType*>(this->type);
     type_id = ext_type->storage_type()->id();
   }
 
@@ -214,6 +214,14 @@ void ArraySpan::SetMembers(const ArrayData& data) {
     this->buffers[i] = {};
   }
 
+  if (type_id == Type::STRING_VIEW || type_id == Type::BINARY_VIEW) {
+    // store the span of character buffers in the third buffer
+    this->buffers[2].data =
+        const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(data.buffers.data() + 2));
+    this->buffers[2].size =
+        static_cast<int64_t>(data.buffers.size() - 2) * sizeof(std::shared_ptr<Buffer>);
+  }
+
   if (type_id == Type::DICTIONARY) {
     this->child_data.resize(1);
     this->child_data[0].SetMembers(*data.dictionary);
@@ -248,6 +256,8 @@ int GetNumBuffers(const DataType& type) {
     case Type::LARGE_BINARY:
     case Type::STRING:
     case Type::LARGE_STRING:
+    case Type::STRING_VIEW:
+    case Type::BINARY_VIEW:
     case Type::DENSE_UNION:
       return 3;
     case Type::EXTENSION:
@@ -330,12 +340,12 @@ void ArraySpan::FillFromScalar(const Scalar& value) {
   } else if (is_base_binary_like(type_id)) {
     const auto& scalar = checked_cast<const BaseBinaryScalar&>(value);
     this->buffers[1].data = reinterpret_cast<uint8_t*>(this->scratch_space);
-    const uint8_t* data_buffer = nullptr;
-    int64_t data_size = 0;
-    if (scalar.is_valid) {
-      data_buffer = scalar.value->data();
-      data_size = scalar.value->size();
-    }
+    static auto kEmptyBuffer = Buffer::FromString("");
+    const auto& value = scalar.is_valid ? scalar.value : kEmptyBuffer;
+    this->buffers[2].data = const_cast<uint8_t*>(value->data());
+    this->buffers[2].size = value->size();
+    this->buffers[2].owner = &value;
+    int64_t data_size = this->buffers[2].size;
     if (is_binary_like(type_id)) {
       SetOffsetsForScalar<int32_t>(this, reinterpret_cast<int32_t*>(this->scratch_space),
                                    data_size);
@@ -344,8 +354,25 @@ void ArraySpan::FillFromScalar(const Scalar& value) {
       SetOffsetsForScalar<int64_t>(this, reinterpret_cast<int64_t*>(this->scratch_space),
                                    data_size);
     }
-    this->buffers[2].data = const_cast<uint8_t*>(data_buffer);
-    this->buffers[2].size = data_size;
+  } else if (type_id == Type::BINARY_VIEW || type_id == Type::STRING_VIEW) {
+    const auto& scalar = checked_cast<const BaseBinaryScalar&>(value);
+
+    this->buffers[1].data = reinterpret_cast<uint8_t*>(this->scratch_space);
+    if (scalar.is_valid) {
+      if (checked_cast<const BinaryViewType*>(type)->has_raw_pointers()) {
+        new (this->scratch_space) StringHeader{
+            scalar.value->data_as<char>(), static_cast<uint32_t>(scalar.value->size())};
+      } else {
+        new (this->scratch_space) StringHeader{
+            scalar.value->data_as<char>(), static_cast<uint32_t>(scalar.value->size()), 0,
+            scalar.value->data_as<char>()};
+      }
+      this->buffers[2].data =
+          const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&scalar.value));
+      this->buffers[2].size = sizeof(std::shared_ptr<Buffer>);
+    } else {
+      new (this->scratch_space) StringHeader{};
+    }
   } else if (type_id == Type::FIXED_SIZE_BINARY) {
     const auto& scalar = checked_cast<const BaseBinaryScalar&>(value);
     this->buffers[1].data = const_cast<uint8_t*>(scalar.value->data());
@@ -687,7 +714,8 @@ struct ViewDataImpl {
       }
 
       RETURN_NOT_OK(CheckInputAvailable());
-      const auto& in_spec = in_layouts[in_layout_idx].buffers[in_buffer_idx];
+      const auto& in_layout = in_layouts[in_layout_idx];
+      const auto& in_spec = in_layout.buffers[in_buffer_idx];
       if (out_spec != in_spec) {
         return InvalidView("incompatible layouts");
       }
@@ -698,6 +726,18 @@ struct ViewDataImpl {
       DCHECK_GT(in_data_item->buffers.size(), in_buffer_idx);
       out_buffers.push_back(in_data_item->buffers[in_buffer_idx]);
       ++in_buffer_idx;
+
+      if (in_buffer_idx == in_layout.buffers.size()) {
+        if (out_layout.variadic_spec != in_layout.variadic_spec) {
+          return InvalidView("incompatible layouts");
+        }
+
+        if (in_layout.variadic_spec) {
+          for (; in_buffer_idx < in_data_item->buffers.size(); ++in_buffer_idx) {
+            out_buffers.push_back(in_data_item->buffers[in_buffer_idx]);
+          }
+        }
+      }
       AdjustInputPointer();
     }
 
diff --git a/cpp/src/arrow/array/data.h b/cpp/src/arrow/array/data.h
index 82a6e733727..f7d1adc3e4b 100644
--- a/cpp/src/arrow/array/data.h
+++ b/cpp/src/arrow/array/data.h
@@ -384,6 +384,7 @@ struct ARROW_EXPORT ArraySpan {
   ArraySpan(const ArrayData& data) {  // NOLINT implicit conversion
     SetMembers(data);
   }
+  /// Warning: this produces an ArraySpan which cannot be safely moved/copied!
   explicit ArraySpan(const Scalar& data) { FillFromScalar(data); }
 
   /// If dictionary-encoded, put dictionary in the first entry
@@ -391,6 +392,7 @@ struct ARROW_EXPORT ArraySpan {
 
   /// \brief Populate ArraySpan to look like an array of length 1 pointing at
   /// the data members of a Scalar value
+  /// Warning: this produces an ArraySpan which cannot be safely moved/copied!
   void FillFromScalar(const Scalar& value);
 
   void SetMembers(const ArrayData& data);
@@ -468,10 +470,12 @@ struct ARROW_EXPORT ArraySpan {
   void SetSlice(int64_t offset, int64_t length) {
     this->offset = offset;
     this->length = length;
-    if (this->type->id() != Type::NA) {
+    if (this->type->id() == Type::NA) {
+      this->null_count = this->length;
+    } else if (this->MayHaveNulls()) {
       this->null_count = kUnknownNullCount;
     } else {
-      this->null_count = this->length;
+      this->null_count = 0;
     }
   }
 
diff --git a/cpp/src/arrow/array/dict_internal.h b/cpp/src/arrow/array/dict_internal.h
index 5245c8d0ff3..acc0534a2ae 100644
--- a/cpp/src/arrow/array/dict_internal.h
+++ b/cpp/src/arrow/array/dict_internal.h
@@ -156,6 +156,37 @@ struct DictionaryTraits<T, enable_if_base_binary<T>> {
   }
 };
 
+template <typename T>
+struct DictionaryTraits<T, enable_if_binary_view_like<T>> {
+  using MemoTableType = typename HashTraits<T>::MemoTableType;
+
+  static_assert(std::is_same_v<MemoTableType, BinaryMemoTable<BinaryBuilder>>);
+
+  // Instead of defining a custom memo table for StringView we reuse BinaryType's,
+  // then convert to string view when we copy data out of the memo table.
+  static Status GetDictionaryArrayData(MemoryPool* pool,
+                                       const std::shared_ptr<DataType>& type,
+                                       const MemoTableType& memo_table,
+                                       int64_t start_offset,
+                                       std::shared_ptr<ArrayData>* out) {
+    DCHECK(type->id() == Type::STRING_VIEW || type->id() == Type::BINARY_VIEW);
+
+    BinaryViewBuilder builder(pool);
+    RETURN_NOT_OK(builder.Resize(memo_table.size() - start_offset));
+    RETURN_NOT_OK(builder.ReserveData(memo_table.values_size()));
+    memo_table.VisitValues(static_cast<int32_t>(start_offset),
+                           [&](std::string_view s) { builder.UnsafeAppend(s); });
+    RETURN_NOT_OK(builder.FinishInternal(out));
+    if (checked_cast<const BinaryViewType&>(*type).has_raw_pointers()) {
+      // the builder produces index/offset string views, so swap to raw pointers
+      RETURN_NOT_OK(
+          SwapStringHeaderPointers(**out, (*out)->GetMutableValues<StringHeader>(1)));
+    }
+    (*out)->type = type;
+    return Status::OK();
+  }
+};
+
 template <typename T>
 struct DictionaryTraits<T, enable_if_fixed_size_binary<T>> {
   using MemoTableType = typename HashTraits<T>::MemoTableType;
diff --git a/cpp/src/arrow/array/util.cc b/cpp/src/arrow/array/util.cc
index 07be8176fc0..09a9c4afa31 100644
--- a/cpp/src/arrow/array/util.cc
+++ b/cpp/src/arrow/array/util.cc
@@ -43,6 +43,9 @@
 #include "arrow/util/decimal.h"
 #include "arrow/util/endian.h"
 #include "arrow/util/logging.h"
+#include "arrow/util/sort.h"
+#include "arrow/util/span.h"
+#include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
 
 namespace arrow {
@@ -267,6 +270,47 @@ class ArrayDataEndianSwapper {
     return Status::OK();
   }
 
+  Status Visit(const BinaryViewType& type) {
+    if (type.has_raw_pointers()) {
+      return Status::Invalid(
+          "Swapping endianness of binary / string view with raw pointers");
+    }
+
+    auto* s = data_->buffers[1]->data_as<StringHeader>();
+    ARROW_ASSIGN_OR_RAISE(auto new_buffer, AllocateBuffer(data_->buffers[1]->size()));
+    auto* new_s = new_buffer->mutable_data_as<StringHeader>();
+
+    // NOTE: data_->length not trusted (see warning above)
+    const int64_t length = data_->buffers[1]->size() / sizeof(StringHeader);
+
+    for (int64_t i = 0; i < length; i++) {
+      auto size = static_cast<uint32_t>(s[i].size());
+#if ARROW_LITTLE_ENDIAN
+      size = bit_util::FromBigEndian(size);
+#else
+      size = bit_util::FromLittleEndian(size);
+#endif
+      if (StringHeader::IsInline(size)) {
+        new_s[i] = s[i];
+        std::memcpy(static_cast<void*>(&new_s[i]), &size, sizeof(uint32_t));
+        continue;
+      }
+
+      uint32_t buffer_index = s[i].GetBufferIndex();
+      uint32_t offset = s[i].GetBufferOffset();
+#if ARROW_LITTLE_ENDIAN
+      buffer_index = bit_util::FromBigEndian(buffer_index);
+      offset = bit_util::FromBigEndian(offset);
+#else
+      buffer_index = bit_util::FromLittleEndian(buffer_index);
+      offset = bit_util::FromLittleEndian(offset);
+#endif
+      new_s[i] = StringHeader{size, s[i].GetPrefix(), buffer_index, offset};
+    }
+    out_->buffers[1] = std::move(new_buffer);
+    return Status::OK();
+  }
+
   Status Visit(const ListType& type) {
     RETURN_NOT_OK(SwapOffsets<int32_t>(1));
     return Status::OK();
@@ -372,6 +416,10 @@ class NullArrayFactory {
       return MaxOf(sizeof(typename T::offset_type) * (length_ + 1));
     }
 
+    Status Visit(const BinaryViewType& type) {
+      return MaxOf(sizeof(StringHeader) * length_);
+    }
+
     Status Visit(const FixedSizeListType& type) {
       return MaxOf(GetBufferLength(type.value_type(), type.list_size() * length_));
     }
@@ -491,6 +539,11 @@ class NullArrayFactory {
     return Status::OK();
   }
 
+  Status Visit(const BinaryViewType&) {
+    out_->buffers.resize(2, buffer_);
+    return Status::OK();
+  }
+
   template <typename T>
   enable_if_var_size_list<T, Status> Visit(const T& type) {
     out_->buffers.resize(2, buffer_);
@@ -577,7 +630,7 @@ class NullArrayFactory {
   }
 
   MemoryPool* pool_;
-  std::shared_ptr<DataType> type_;
+  const std::shared_ptr<DataType>& type_;
   int64_t length_;
   std::shared_ptr<ArrayData> out_;
   std::shared_ptr<Buffer> buffer_;
@@ -638,8 +691,26 @@ class RepeatedArrayFactory {
     RETURN_NOT_OK(CreateBufferOf(value->data(), value->size(), &values_buffer));
     auto size = static_cast<typename T::offset_type>(value->size());
     RETURN_NOT_OK(CreateOffsetsBuffer(size, &offsets_buffer));
-    out_ = std::make_shared<typename TypeTraits<T>::ArrayType>(length_, offsets_buffer,
-                                                               values_buffer);
+    out_ = std::make_shared<typename TypeTraits<T>::ArrayType>(
+        length_, std::move(offsets_buffer), std::move(values_buffer));
+    return Status::OK();
+  }
+
+  template <typename T>
+  enable_if_binary_view_like<T, Status> Visit(const T&) {
+    const std::shared_ptr<Buffer>& value =
+        checked_cast<const typename TypeTraits<T>::ScalarType&>(scalar_).value;
+
+    StringHeader header{std::string_view{*value}};
+    std::shared_ptr<Buffer> header_buffer;
+    RETURN_NOT_OK(CreateBufferOf(&header, sizeof(header), &header_buffer));
+
+    BufferVector char_buffers;
+    if (!header.IsInline()) {
+      char_buffers.push_back(value);
+    }
+    out_ = std::make_shared<typename TypeTraits<T>::ArrayType>(
+        length_, std::move(header_buffer), std::move(char_buffers));
     return Status::OK();
   }
 
@@ -934,5 +1005,222 @@ std::vector<ArrayVector> RechunkArraysConsistently(
   return rechunked_groups;
 }
 
+namespace {
+Status FromRawPointerStringHeaders(const ArraySpan& raw,
+                                   util::span<const std::shared_ptr<Buffer>> char_buffers,
+                                   StringHeader* io) {
+  DCHECK_NE(char_buffers.size(), 0);
+
+  auto IsInBuffer = [](const Buffer& buffer, StringHeader s) {
+    return buffer.data_as<char>() <= s.data() &&
+           buffer.data_as<char>() + buffer.size() >= s.data() + s.size();
+  };
+
+  auto Write = [&](auto find_containing_buffer) {
+    // Given `find_containing_buffer` which looks up the index of a buffer containing
+    // a StringHeader, write an equivalent buffer of index/offset string views.
+    static const Buffer kEmptyBuffer{""};
+    const Buffer* buffer_containing_previous_view = &kEmptyBuffer;
+    uint32_t buffer_index;
+
+    auto* raw_ptr = raw.GetValues<StringHeader>(1);
+
+    bool all_valid = true;
+    VisitNullBitmapInline(
+        raw.buffers[0].data, raw.offset, raw.length, raw.null_count,
+        [&] {
+          // Copied to a local variable, so even if io == raw_ptr
+          // we can modify safely.
+          auto s = *raw_ptr++;
+
+          if (!s.IsInline()) {
+            // Fast path: for most string view arrays, we'll have runs
+            // of views into the same buffer.
+            if (ARROW_PREDICT_FALSE(!IsInBuffer(*buffer_containing_previous_view, s))) {
+              auto found = find_containing_buffer(s);
+              if (ARROW_PREDICT_FALSE(!found)) {
+                all_valid = false;
+                return;
+              }
+              // Assume that we're at the start of a run of views into
+              // char_buffers[buffer_index]; adjust the fast path's pointer accordingly
+              buffer_index = *found;
+              buffer_containing_previous_view = char_buffers[buffer_index].get();
+            }
+
+            s.SetIndexOffset(
+                buffer_index,
+                static_cast<uint32_t>(
+                    s.data() - char_buffers[buffer_index]->template data_as<char>()));
+          }
+          *io++ = s;
+        },
+        [&] {
+          ++raw_ptr;
+          *io++ = {};
+        });
+
+    if (!all_valid) {
+      return Status::IndexError(
+          "A header pointed outside the provided character buffers");
+    }
+    return Status::OK();
+  };
+
+  auto LinearSearch = [&](StringHeader s) -> std::optional<uint32_t> {
+    uint32_t buffer_index = 0;
+    for (const auto& char_buffer : char_buffers) {
+      if (IsInBuffer(*char_buffer, s)) return buffer_index;
+      ++buffer_index;
+    }
+    return {};
+  };
+
+  if (char_buffers.size() <= 32) {
+    // If there are few buffers to search through, sorting/binary search is not
+    // worthwhile. TODO(bkietz) benchmark this and get a less magic number here.
+    return Write(LinearSearch);
+  }
+
+  auto sort_indices = ArgSort<uint32_t>(
+      char_buffers, [](const auto& l, const auto& r) { return l->data() < r->data(); });
+
+  auto first_overlapping = std::adjacent_find(
+      sort_indices.begin(), sort_indices.end(), [&](uint32_t before, uint32_t after) {
+        return char_buffers[before]->data() + char_buffers[before]->size() <=
+               char_buffers[after]->data();
+      });
+  if (ARROW_PREDICT_FALSE(first_overlapping != sort_indices.end())) {
+    // Using a binary search with overlapping buffers would not *uniquely* identify
+    // a potentially-containing buffer. Moreover this should be a fairly rare case
+    // so optimizing for it seems premature.
+    return Write(LinearSearch);
+  }
+
+  auto BinarySearch = [&](StringHeader s) -> std::optional<uint32_t> {
+    // Find the first buffer whose data starts after the data in view-
+    // only buffers *before* this could contain view. Since we've additionally
+    // checked that the buffers do not overlap, only the buffer *immediately before*
+    // this could contain view.
+    auto one_past_potential_super =
+        std::upper_bound(sort_indices.begin(), sort_indices.end(), s,
+                         [&](const StringHeader& s, int64_t i) {
+                           return IsInBuffer(*char_buffers[i], s);
+                         });
+
+    if (ARROW_PREDICT_FALSE(one_past_potential_super == sort_indices.begin())) {
+      return {};
+    }
+
+    uint32_t buffer_index = *(one_past_potential_super - 1);
+    const Buffer& char_buffer = *char_buffers[buffer_index];
+    if (ARROW_PREDICT_TRUE(IsInBuffer(char_buffer, s))) return buffer_index;
+
+    return {};
+  };
+
+  return Write(BinarySearch);
+}
+
+Status ToRawPointerStringHeaders(const ArraySpan& io,
+                                 util::span<const std::shared_ptr<Buffer>> char_buffers,
+                                 StringHeader* raw) {
+  DCHECK_NE(char_buffers.size(), 0);
+
+  uint32_t buffer_index = 0;
+  const char* buffer_data = char_buffers[0]->data_as<char>();
+  auto* io_ptr = io.GetValues<StringHeader>(1);
+
+  bool all_valid = true;
+  VisitNullBitmapInline(
+      io.buffers[0].data, io.offset, io.length, io.null_count,
+      [&] {
+        // Copied to a local variable, so even if raw == io_ptr
+        // we can modify safely.
+        auto s = *io_ptr++;
+
+        if (!s.IsInline()) {
+          // Fast path: for most string view arrays, we'll have runs
+          // of views into the same buffer.
+          if (ARROW_PREDICT_FALSE(s.GetBufferIndex() != buffer_index)) {
+            if (ARROW_PREDICT_FALSE(s.GetBufferIndex() >= char_buffers.size())) {
+              all_valid = false;
+              return;
+            }
+            // Assume that we're at the start of a run of views into
+            // char_buffers[buffer_index]; adjust the fast path's pointer accordingly
+            buffer_index = s.GetBufferIndex();
+            buffer_data = char_buffers[buffer_index]->data_as<char>();
+          }
+          s.SetRawPointer(buffer_data + s.GetBufferOffset());
+        }
+        *raw++ = s;
+      },
+      [&] {
+        ++io_ptr;
+        *raw++ = {};
+      });
+
+  if (!all_valid) {
+    return Status::IndexError("A header pointed outside the provided character buffers");
+  }
+  return Status::OK();
+}
+}  // namespace
+
+Status SwapStringHeaderPointers(const ArraySpan& in, StringHeader* out) {
+  util::span char_buffers{
+      reinterpret_cast<const std::shared_ptr<Buffer>*>(in.buffers[2].data),
+      static_cast<size_t>(in.buffers[2].size / sizeof(std::shared_ptr<Buffer>))};
+
+  if (char_buffers.size() == 0) {
+    // If there are no character buffers, then all string views must be inline.
+    // In this case the buffer does not require swizzling between pointers and
+    // index/offsets.
+    auto* in_ptr = in.GetValues<StringHeader>(1);
+
+    bool all_inline = true;
+    VisitNullBitmapInline(
+        in.buffers[0].data, in.offset, in.length, in.null_count,
+        [&] {
+          all_inline = all_inline && in_ptr->IsInline();
+          auto s = *in_ptr++;
+          *out++ = s;
+        },
+        [&] {
+          ++in_ptr;
+          *out++ = {};
+        });
+    if (ARROW_PREDICT_FALSE(!all_inline)) {
+      return Status::IndexError(
+          "A header was not inline when no character buffers were provided");
+    }
+    return Status::OK();
+  }
+
+  return checked_cast<const BinaryViewType*>(in.type)->has_raw_pointers()
+             ? FromRawPointerStringHeaders(in, char_buffers, out)
+             : ToRawPointerStringHeaders(in, char_buffers, out);
+}
+
+void StringHeadersFromStrings(const ArraySpan& strings, StringHeader* s) {
+  auto* buffer_data = reinterpret_cast<const char*>(strings.buffers[2].data);
+  VisitArraySpanInline<StringType>(
+      strings,
+      [&](std::string_view v) {
+        *s++ = StringHeader{v.data(), static_cast<uint32_t>(v.size()), 0, buffer_data};
+      },
+      [&] { *s++ = StringHeader{}; });
+}
+
+void RawPointerStringHeadersFromStrings(const ArraySpan& strings, StringHeader* s) {
+  VisitArraySpanInline<StringType>(
+      strings,
+      [&](std::string_view v) {
+        *s++ = StringHeader{v.data(), static_cast<uint32_t>(v.size())};
+      },
+      [&] { *s++ = StringHeader{}; });
+}
+
 }  // namespace internal
 }  // namespace arrow
diff --git a/cpp/src/arrow/array/util.h b/cpp/src/arrow/array/util.h
index 6e6c61bd03d..adae067db0c 100644
--- a/cpp/src/arrow/array/util.h
+++ b/cpp/src/arrow/array/util.h
@@ -85,5 +85,26 @@ Result<std::shared_ptr<ArrayData>> SwapEndianArrayData(
 ARROW_EXPORT
 std::vector<ArrayVector> RechunkArraysConsistently(const std::vector<ArrayVector>&);
 
+/// Convert between index/offset and raw pointer StringHeaders.
+///
+/// This function can be used to overwrite a buffer of StringHeader if desired,
+/// IE it is supported for `in.buffers[1].data == out`.
+///
+/// Note that calling this function is not necessary if all StringHeaders happen to be
+/// Inline; this is usually efficiently detectable by checking for an absence of any
+/// character buffers.
+///
+/// Will raise IndexError if a header views memory outside the provided character buffers.
+ARROW_EXPORT
+Status SwapStringHeaderPointers(const ArraySpan& in, StringHeader* out);
+
+/// Fill a buffer of index/offset StringHeader from a dense string array
+ARROW_EXPORT
+void StringHeadersFromStrings(const ArraySpan& strings, StringHeader* io);
+
+/// Fill a buffer of raw pointer StringHeader from a dense string array
+ARROW_EXPORT
+void RawPointerStringHeadersFromStrings(const ArraySpan& strings, StringHeader* raw);
+
 }  // namespace internal
 }  // namespace arrow
diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc
index 0f2bd458357..63f97bf38f9 100644
--- a/cpp/src/arrow/array/validate.cc
+++ b/cpp/src/arrow/array/validate.cc
@@ -31,41 +31,44 @@
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/ree_util.h"
+#include "arrow/util/sort.h"
+#include "arrow/util/string.h"
+#include "arrow/util/string_header.h"
+#include "arrow/util/unreachable.h"
 #include "arrow/util/utf8.h"
 #include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
 
-namespace arrow {
-namespace internal {
+namespace arrow::internal {
 
 namespace {
 
 struct UTF8DataValidator {
   const ArrayData& data;
 
-  Status Visit(const DataType&) {
-    // Default, should be unreachable
-    return Status::NotImplemented("");
-  }
-
-  template <typename StringType>
-  enable_if_string<StringType, Status> Visit(const StringType&) {
-    util::InitializeUTF8();
+  template <typename T>
+  Status Visit(const T&) {
+    if constexpr (std::is_same_v<T, StringType> || std::is_same_v<T, LargeStringType> ||
+                  std::is_same_v<T, StringViewType>) {
+      util::InitializeUTF8();
 
-    int64_t i = 0;
-    return VisitArraySpanInline<StringType>(
-        data,
-        [&](std::string_view v) {
-          if (ARROW_PREDICT_FALSE(!util::ValidateUTF8(v))) {
-            return Status::Invalid("Invalid UTF8 sequence at string index ", i);
-          }
-          ++i;
-          return Status::OK();
-        },
-        [&]() {
-          ++i;
-          return Status::OK();
-        });
+      int64_t i = 0;
+      return VisitArraySpanInline<T>(
+          data,
+          [&](std::string_view v) {
+            if (ARROW_PREDICT_FALSE(!util::ValidateUTF8(v))) {
+              return Status::Invalid("Invalid UTF8 sequence at string index ", i);
+            }
+            ++i;
+            return Status::OK();
+          },
+          [&]() {
+            ++i;
+            return Status::OK();
+          });
+    } else {
+      Unreachable("utf-8 validation of non string type");
+    }
   }
 };
 
@@ -74,10 +77,7 @@ struct BoundsChecker {
   int64_t min_value;
   int64_t max_value;
 
-  Status Visit(const DataType&) {
-    // Default, should be unreachable
-    return Status::NotImplemented("");
-  }
+  Status Visit(const DataType&) { Unreachable("bounds checking of non integer type"); }
 
   template <typename IntegerType>
   enable_if_integer<IntegerType, Status> Visit(const IntegerType&) {
@@ -169,6 +169,14 @@ struct ValidateArrayImpl {
     return Status::OK();
   }
 
+  Status Visit(const StringViewType& type) {
+    RETURN_NOT_OK(ValidateBinaryView(type));
+    if (full_validation) {
+      RETURN_NOT_OK(ValidateUTF8(data));
+    }
+    return Status::OK();
+  }
+
   Status Visit(const Date64Type& type) {
     RETURN_NOT_OK(ValidateFixedWidthBuffers());
 
@@ -248,6 +256,8 @@ struct ValidateArrayImpl {
 
   Status Visit(const LargeBinaryType& type) { return ValidateBinaryLike(type); }
 
+  Status Visit(const BinaryViewType& type) { return ValidateBinaryView(type); }
+
   Status Visit(const ListType& type) { return ValidateListLike(type); }
 
   Status Visit(const LargeListType& type) { return ValidateListLike(type); }
@@ -453,7 +463,14 @@ struct ValidateArrayImpl {
       return Status::Invalid("Array length is negative");
     }
 
-    if (data.buffers.size() != layout.buffers.size()) {
+    if (layout.variadic_spec) {
+      if (data.buffers.size() < layout.buffers.size()) {
+        return Status::Invalid("Expected at least ", layout.buffers.size(),
+                               " buffers in array "
+                               "of type ",
+                               type.ToString(), ", got ", data.buffers.size());
+      }
+    } else if (data.buffers.size() != layout.buffers.size()) {
       return Status::Invalid("Expected ", layout.buffers.size(),
                              " buffers in array "
                              "of type ",
@@ -469,7 +486,9 @@ struct ValidateArrayImpl {
 
     for (int i = 0; i < static_cast<int>(data.buffers.size()); ++i) {
       const auto& buffer = data.buffers[i];
-      const auto& spec = layout.buffers[i];
+      const auto& spec = i < static_cast<int>(layout.buffers.size())
+                             ? layout.buffers[i]
+                             : *layout.variadic_spec;
 
       if (buffer == nullptr) {
         continue;
@@ -595,6 +614,63 @@ struct ValidateArrayImpl {
     return Status::OK();
   }
 
+  Status ValidateBinaryView(const BinaryViewType& type) {
+    int64_t headers_byte_size = data.buffers[1]->size();
+    int64_t required_headers = data.length + data.offset;
+    if (static_cast<int64_t>(headers_byte_size / sizeof(StringHeader)) <
+        required_headers) {
+      return Status::Invalid("Header buffer size (bytes): ", headers_byte_size,
+                             " isn't large enough for length: ", data.length,
+                             " and offset: ", data.offset);
+    }
+
+    if (!full_validation) {
+      return Status::OK();
+    }
+
+    if (type.has_raw_pointers()) {
+      // TODO(bkietz) It may be preferable to extract the validation logic which is in
+      // the raw pointer - index/offset view array conversion functions and actually
+      // validate raw pointer view arrays, rather than giving up here
+      return Status::OK();
+    }
+
+    auto* s = data.GetValues<StringHeader>(1);
+    for (int64_t i = 0; i < data.length; ++i, ++s) {
+      if (data.IsNull(i)) continue;
+
+      if (s->IsInline()) continue;
+
+      size_t buffer_index = s->GetBufferIndex();
+      if (ARROW_PREDICT_FALSE(buffer_index + 2 >= data.buffers.size())) {
+        return Status::IndexError("String view at slot ", i, " references buffer ",
+                                  buffer_index, " but there are only ",
+                                  data.buffers.size() - 2, " character buffers");
+      }
+
+      size_t begin = s->GetBufferOffset();
+      size_t end = begin + s->size();
+      const auto& buffer = data.buffers[buffer_index + 2];
+      auto size = static_cast<size_t>(buffer->size());
+      if (ARROW_PREDICT_FALSE(end > size)) {
+        return Status::IndexError("String view at slot ", i, " references range ", begin,
+                                  "-", end, " of buffer ", buffer_index,
+                                  " but that buffer is only ", size, " bytes long");
+      }
+
+      const char* data = buffer->data_as<char>() + begin;
+      if (ARROW_PREDICT_FALSE(
+              std::memcmp(data, s->GetInlineData(), StringHeader::kPrefixSize) != 0)) {
+        return Status::Invalid("String view at slot ", i, " has inlined prefix 0x",
+                               HexEncode(s->GetInlineData(), StringHeader::kPrefixSize),
+                               " but the out-of-line character data begins with 0x",
+                               HexEncode(data, StringHeader::kPrefixSize));
+      }
+    }
+
+    return Status::OK();
+  }
+
   template <typename ListType>
   Status ValidateListLike(const ListType& type) {
     const ArrayData& values = *data.child_data[0];
@@ -796,7 +872,8 @@ Status ValidateArrayFull(const Array& array) { return ValidateArrayFull(*array.d
 
 ARROW_EXPORT
 Status ValidateUTF8(const ArrayData& data) {
-  DCHECK(data.type->id() == Type::STRING || data.type->id() == Type::LARGE_STRING);
+  DCHECK(data.type->id() == Type::STRING || data.type->id() == Type::STRING_VIEW ||
+         data.type->id() == Type::LARGE_STRING);
   UTF8DataValidator validator{data};
   return VisitTypeInline(*data.type, &validator);
 }
@@ -804,5 +881,4 @@ Status ValidateUTF8(const ArrayData& data) {
 ARROW_EXPORT
 Status ValidateUTF8(const Array& array) { return ValidateUTF8(*array.data()); }
 
-}  // namespace internal
-}  // namespace arrow
+}  // namespace arrow::internal
diff --git a/cpp/src/arrow/buffer.h b/cpp/src/arrow/buffer.h
index 65f1abda161..ac231e72342 100644
--- a/cpp/src/arrow/buffer.h
+++ b/cpp/src/arrow/buffer.h
@@ -186,6 +186,10 @@ class ARROW_EXPORT Buffer {
 #endif
     return ARROW_PREDICT_TRUE(is_cpu_) ? data_ : NULLPTR;
   }
+  template <typename T>
+  const T* data_as() const {
+    return reinterpret_cast<const T*>(data());
+  }
 
   /// \brief Return a writable pointer to the buffer's data
   ///
@@ -203,6 +207,10 @@ class ARROW_EXPORT Buffer {
     return ARROW_PREDICT_TRUE(is_cpu_ && is_mutable_) ? const_cast<uint8_t*>(data_)
                                                       : NULLPTR;
   }
+  template <typename T>
+  T* mutable_data_as() {
+    return reinterpret_cast<T*>(mutable_data());
+  }
 
   /// \brief Return the device address of the buffer's data
   uintptr_t address() const { return reinterpret_cast<uintptr_t>(data_); }
diff --git a/cpp/src/arrow/buffer_builder.h b/cpp/src/arrow/buffer_builder.h
index 5f37e552004..ab397485d60 100644
--- a/cpp/src/arrow/buffer_builder.h
+++ b/cpp/src/arrow/buffer_builder.h
@@ -117,6 +117,9 @@ class ARROW_EXPORT BufferBuilder {
     UnsafeAppend(data, length);
     return Status::OK();
   }
+  Status Append(std::string_view v) {
+    return Append(v.data(), static_cast<int64_t>(v.size()));
+  }
 
   /// \brief Append copies of a value to the buffer
   ///
@@ -138,6 +141,9 @@ class ARROW_EXPORT BufferBuilder {
     memcpy(data_ + size_, data, static_cast<size_t>(length));
     size_ += length;
   }
+  void UnsafeAppend(std::string_view v) {
+    UnsafeAppend(v.data(), static_cast<int64_t>(v.size()));
+  }
 
   void UnsafeAppend(const int64_t num_copies, uint8_t value) {
     memset(data_ + size_, value, static_cast<size_t>(num_copies));
diff --git a/cpp/src/arrow/builder.cc b/cpp/src/arrow/builder.cc
index caddbf9db55..a1bc398cca4 100644
--- a/cpp/src/arrow/builder.cc
+++ b/cpp/src/arrow/builder.cc
@@ -148,6 +148,8 @@ struct DictionaryBuilderCase {
   Status Visit(const StringType&) { return CreateFor<StringType>(); }
   Status Visit(const LargeBinaryType&) { return CreateFor<LargeBinaryType>(); }
   Status Visit(const LargeStringType&) { return CreateFor<LargeStringType>(); }
+  Status Visit(const BinaryViewType&) { return CreateFor<BinaryViewType>(); }
+  Status Visit(const StringViewType&) { return CreateFor<StringViewType>(); }
   Status Visit(const FixedSizeBinaryType&) { return CreateFor<FixedSizeBinaryType>(); }
   Status Visit(const Decimal128Type&) { return CreateFor<Decimal128Type>(); }
   Status Visit(const Decimal256Type&) { return CreateFor<Decimal256Type>(); }
@@ -162,6 +164,11 @@ struct DictionaryBuilderCase {
 
   template <typename ValueType>
   Status CreateFor() {
+    if constexpr (is_binary_view_like_type<ValueType>::value) {
+      if (checked_cast<const ValueType&>(*value_type).has_raw_pointers()) {
+        return NotImplemented(*value_type);
+      }
+    }
     using AdaptiveBuilderType = DictionaryBuilder<ValueType>;
     if (dictionary != nullptr) {
       out->reset(new AdaptiveBuilderType(dictionary, pool));
@@ -190,7 +197,12 @@ struct DictionaryBuilderCase {
 
 struct MakeBuilderImpl {
   template <typename T>
-  enable_if_not_nested<T, Status> Visit(const T&) {
+  enable_if_not_nested<T, Status> Visit(const T& t) {
+    if constexpr (is_binary_view_like_type<T>::value) {
+      if (t.has_raw_pointers()) {
+        return NotImplemented();
+      }
+    }
     out.reset(new typename TypeTraits<T>::BuilderType(type, pool));
     return Status::OK();
   }
diff --git a/cpp/src/arrow/compare.cc b/cpp/src/arrow/compare.cc
index df41cd22c9e..c318a54b130 100644
--- a/cpp/src/arrow/compare.cc
+++ b/cpp/src/arrow/compare.cc
@@ -261,6 +261,36 @@ class RangeDataEqualsImpl {
   // Also matches StringType
   Status Visit(const BinaryType& type) { return CompareBinary(type); }
 
+  // Also matches StringViewType
+  Status Visit(const BinaryViewType& type) {
+    auto* left_values = left_.GetValues<StringHeader>(1) + left_start_idx_;
+    auto* right_values = right_.GetValues<StringHeader>(1) + right_start_idx_;
+    if (type.has_raw_pointers()) {
+      VisitValidRuns([&](int64_t i, int64_t length) {
+        for (auto end_i = i + length; i < end_i; ++i) {
+          if (left_values[i] != right_values[i]) {
+            return false;
+          }
+        }
+        return true;
+      });
+      return Status::OK();
+    }
+
+    auto* left_buffers = left_.buffers.data() + 2;
+    auto* right_buffers = right_.buffers.data() + 2;
+    VisitValidRuns([&](int64_t i, int64_t length) {
+      for (auto end_i = i + length; i < end_i; ++i) {
+        if (!left_values[i].EqualsIndexOffset(left_buffers, right_values[i],
+                                              right_buffers)) {
+          return false;
+        }
+      }
+      return true;
+    });
+    return Status::OK();
+  }
+
   // Also matches LargeStringType
   Status Visit(const LargeBinaryType& type) { return CompareBinary(type); }
 
@@ -632,6 +662,12 @@ class TypeEqualsVisitor {
     return Status::OK();
   }
 
+  Status Visit(const BinaryViewType& left) {
+    const auto& right = checked_cast<const BinaryViewType&>(right_);
+    result_ = left.has_raw_pointers() == right.has_raw_pointers();
+    return Status::OK();
+  }
+
   template <typename T>
   enable_if_interval<T, Status> Visit(const T& left) {
     const auto& right = checked_cast<const IntervalType&>(right_);
@@ -802,8 +838,7 @@ class ScalarEqualsVisitor {
   Status Visit(const DoubleScalar& left) { return CompareFloating(left); }
 
   template <typename T>
-  typename std::enable_if<std::is_base_of<BaseBinaryScalar, T>::value, Status>::type
-  Visit(const T& left) {
+  enable_if_t<std::is_base_of<BaseBinaryScalar, T>::value, Status> Visit(const T& left) {
     const auto& right = checked_cast<const BaseBinaryScalar&>(right_);
     result_ = internal::SharedPtrEquals(left.value, right.value);
     return Status::OK();
diff --git a/cpp/src/arrow/compute/exec.cc b/cpp/src/arrow/compute/exec.cc
index c18dfa09522..231ce0e4bf4 100644
--- a/cpp/src/arrow/compute/exec.cc
+++ b/cpp/src/arrow/compute/exec.cc
@@ -302,6 +302,9 @@ void ComputeDataPreallocate(const DataType& type,
     case Type::LARGE_LIST:
       widths->emplace_back(64, /*added_length=*/1);
       return;
+    case Type::BINARY_VIEW:
+    case Type::STRING_VIEW:
+      widths->emplace_back(static_cast<int>(sizeof(StringHeader) * 8));
     default:
       break;
   }
diff --git a/cpp/src/arrow/compute/kernel.cc b/cpp/src/arrow/compute/kernel.cc
index fd554ba3d83..e05989ad7c2 100644
--- a/cpp/src/arrow/compute/kernel.cc
+++ b/cpp/src/arrow/compute/kernel.cc
@@ -175,7 +175,7 @@ std::shared_ptr<TypeMatcher> DurationTypeUnit(TimeUnit::type unit) {
 
 class IntegerMatcher : public TypeMatcher {
  public:
-  IntegerMatcher() {}
+  IntegerMatcher() = default;
 
   bool Matches(const DataType& type) const override { return is_integer(type.id()); }
 
@@ -194,7 +194,7 @@ std::shared_ptr<TypeMatcher> Integer() { return std::make_shared<IntegerMatcher>
 
 class PrimitiveMatcher : public TypeMatcher {
  public:
-  PrimitiveMatcher() {}
+  PrimitiveMatcher() = default;
 
   bool Matches(const DataType& type) const override { return is_primitive(type.id()); }
 
@@ -213,7 +213,7 @@ std::shared_ptr<TypeMatcher> Primitive() { return std::make_shared<PrimitiveMatc
 
 class BinaryLikeMatcher : public TypeMatcher {
  public:
-  BinaryLikeMatcher() {}
+  BinaryLikeMatcher() = default;
 
   bool Matches(const DataType& type) const override { return is_binary_like(type.id()); }
 
@@ -233,7 +233,7 @@ std::shared_ptr<TypeMatcher> BinaryLike() {
 
 class LargeBinaryLikeMatcher : public TypeMatcher {
  public:
-  LargeBinaryLikeMatcher() {}
+  LargeBinaryLikeMatcher() = default;
 
   bool Matches(const DataType& type) const override {
     return is_large_binary_like(type.id());
@@ -249,9 +249,35 @@ class LargeBinaryLikeMatcher : public TypeMatcher {
   std::string ToString() const override { return "large-binary-like"; }
 };
 
+std::shared_ptr<TypeMatcher> LargeBinaryLike() {
+  return std::make_shared<LargeBinaryLikeMatcher>();
+}
+
+class BinaryViewLikeMatcher : public TypeMatcher {
+ public:
+  BinaryViewLikeMatcher() = default;
+
+  bool Matches(const DataType& type) const override {
+    return type.id() == Type::BINARY_VIEW || type.id() == Type::STRING_VIEW;
+  }
+
+  bool Equals(const TypeMatcher& other) const override {
+    if (this == &other) {
+      return true;
+    }
+    auto casted = dynamic_cast<const BinaryViewLikeMatcher*>(&other);
+    return casted != nullptr;
+  }
+  std::string ToString() const override { return "binary-view-like"; }
+};
+
+std::shared_ptr<TypeMatcher> BinaryViewLike() {
+  return std::make_shared<BinaryViewLikeMatcher>();
+}
+
 class FixedSizeBinaryLikeMatcher : public TypeMatcher {
  public:
-  FixedSizeBinaryLikeMatcher() {}
+  FixedSizeBinaryLikeMatcher() = default;
 
   bool Matches(const DataType& type) const override {
     return is_fixed_size_binary(type.id());
@@ -267,10 +293,6 @@ class FixedSizeBinaryLikeMatcher : public TypeMatcher {
   std::string ToString() const override { return "fixed-size-binary-like"; }
 };
 
-std::shared_ptr<TypeMatcher> LargeBinaryLike() {
-  return std::make_shared<LargeBinaryLikeMatcher>();
-}
-
 std::shared_ptr<TypeMatcher> FixedSizeBinaryLike() {
   return std::make_shared<FixedSizeBinaryLikeMatcher>();
 }
diff --git a/cpp/src/arrow/compute/kernel.h b/cpp/src/arrow/compute/kernel.h
index a52636aeb6b..7ca2a661839 100644
--- a/cpp/src/arrow/compute/kernel.h
+++ b/cpp/src/arrow/compute/kernel.h
@@ -134,6 +134,9 @@ ARROW_EXPORT std::shared_ptr<TypeMatcher> BinaryLike();
 // Match types using 64-bit varbinary representation
 ARROW_EXPORT std::shared_ptr<TypeMatcher> LargeBinaryLike();
 
+// Match types using the view varbinary representation
+ARROW_EXPORT std::shared_ptr<TypeMatcher> BinaryViewLike();
+
 // Match any fixed binary type
 ARROW_EXPORT std::shared_ptr<TypeMatcher> FixedSizeBinaryLike();
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_internal.cc b/cpp/src/arrow/compute/kernels/scalar_cast_internal.cc
index 8cf5a04addb..5a671cd05c8 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_internal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_internal.cc
@@ -170,12 +170,6 @@ Status CastFromNull(KernelContext* ctx, const ExecSpan& batch, ExecResult* out)
   return Status::OK();
 }
 
-Result<TypeHolder> ResolveOutputFromOptions(KernelContext* ctx,
-                                            const std::vector<TypeHolder>&) {
-  const CastOptions& options = checked_cast<const CastState&>(*ctx->state()).options;
-  return options.to_type;
-}
-
 /// You will see some of kernels with
 ///
 /// kOutputTargetType
@@ -184,8 +178,10 @@ Result<TypeHolder> ResolveOutputFromOptions(KernelContext* ctx,
 /// easiest initial way to get the requested cast type including the TimeUnit
 /// to the kernel (which is needed to compute the output) was through
 /// CastOptions
-
-OutputType kOutputTargetType(ResolveOutputFromOptions);
+OutputType kOutputTargetType([](KernelContext* ctx,
+                                const std::vector<TypeHolder>&) -> Result<TypeHolder> {
+  return CastState::Get(ctx).to_type;
+});
 
 Status ZeroCopyCastExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
   // TODO(wesm): alternative strategy for zero copy casts after ARROW-16576
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_internal.h b/cpp/src/arrow/compute/kernels/scalar_cast_internal.h
index 0a57e3381d3..c32a26cc948 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_internal.h
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_internal.h
@@ -71,9 +71,6 @@ void AddZeroCopyCast(Type::type in_type_id, InputType in_type, OutputType out_ty
                      CastFunction* func);
 
 // OutputType::Resolver that returns a type the type from CastOptions
-Result<TypeHolder> ResolveOutputFromOptions(KernelContext* ctx,
-                                            const std::vector<TypeHolder>& args);
-
 ARROW_EXPORT extern OutputType kOutputTargetType;
 
 // Add generic casts to out_ty from:
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc b/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc
index a02f83351b3..c9bbcc94a2e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc
@@ -726,7 +726,7 @@ std::shared_ptr<CastFunction> GetCastToFloating(std::string name) {
 }
 
 std::shared_ptr<CastFunction> GetCastToDecimal128() {
-  OutputType sig_out_ty(ResolveOutputFromOptions);
+  OutputType sig_out_ty = kOutputTargetType;
 
   auto func = std::make_shared<CastFunction>("cast_decimal", Type::DECIMAL128);
   AddCommonCasts(Type::DECIMAL128, sig_out_ty, func.get());
@@ -761,7 +761,7 @@ std::shared_ptr<CastFunction> GetCastToDecimal128() {
 }
 
 std::shared_ptr<CastFunction> GetCastToDecimal256() {
-  OutputType sig_out_ty(ResolveOutputFromOptions);
+  OutputType sig_out_ty = kOutputTargetType;
 
   auto func = std::make_shared<CastFunction>("cast_decimal256", Type::DECIMAL256);
   AddCommonCasts(Type::DECIMAL256, sig_out_ty, func.get());
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_string.cc b/cpp/src/arrow/compute/kernels/scalar_cast_string.cc
index ebeb597207a..25e79baab35 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_string.cc
@@ -25,8 +25,11 @@
 #include "arrow/compute/kernels/scalar_cast_internal.h"
 #include "arrow/compute/kernels/temporal_internal.h"
 #include "arrow/result.h"
+#include "arrow/util/cpu_info.h"
 #include "arrow/util/formatting.h"
 #include "arrow/util/int_util.h"
+#include "arrow/util/span.h"
+#include "arrow/util/unreachable.h"
 #include "arrow/util/utf8_internal.h"
 #include "arrow/visit_data_inline.h"
 
@@ -36,8 +39,7 @@ using internal::StringFormatter;
 using util::InitializeUTF8;
 using util::ValidateUTF8Inline;
 
-namespace compute {
-namespace internal {
+namespace compute::internal {
 
 namespace {
 
@@ -53,7 +55,7 @@ struct NumericToStringCastFunctor {
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const ArraySpan& input = batch[0].array;
     FormatterType formatter(input.type);
-    BuilderType builder(input.type->GetSharedPtr(), ctx->memory_pool());
+    BuilderType builder(TypeTraits<O>::type_singleton(), ctx->memory_pool());
     RETURN_NOT_OK(VisitArraySpanInline<I>(
         input,
         [&](value_type v) {
@@ -77,7 +79,7 @@ struct DecimalToStringCastFunctor {
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const ArraySpan& input = batch[0].array;
     FormatterType formatter(input.type);
-    BuilderType builder(input.type->GetSharedPtr(), ctx->memory_pool());
+    BuilderType builder(TypeTraits<O>::type_singleton(), ctx->memory_pool());
     RETURN_NOT_OK(VisitArraySpanInline<I>(
         input,
         [&](std::string_view bytes) {
@@ -105,7 +107,7 @@ struct TemporalToStringCastFunctor {
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const ArraySpan& input = batch[0].array;
     FormatterType formatter(input.type);
-    BuilderType builder(input.type->GetSharedPtr(), ctx->memory_pool());
+    BuilderType builder(TypeTraits<O>::type_singleton(), ctx->memory_pool());
     RETURN_NOT_OK(VisitArraySpanInline<I>(
         input,
         [&](value_type v) {
@@ -130,7 +132,7 @@ struct TemporalToStringCastFunctor<O, TimestampType> {
     const ArraySpan& input = batch[0].array;
     const auto& timezone = GetInputTimezone(*input.type);
     const auto& ty = checked_cast<const TimestampType&>(*input.type);
-    BuilderType builder(input.type->GetSharedPtr(), ctx->memory_pool());
+    BuilderType builder(TypeTraits<O>::type_singleton(), ctx->memory_pool());
 
     // Preallocate
     int64_t string_length = 19;  // YYYY-MM-DD HH:MM:SS
@@ -284,107 +286,214 @@ Status CastBinaryToBinaryOffsets<int64_t, int32_t>(KernelContext* ctx,
 }
 
 template <typename O, typename I>
-enable_if_base_binary<I, Status> BinaryToBinaryCastExec(KernelContext* ctx,
-                                                        const ExecSpan& batch,
-                                                        ExecResult* out) {
-  const CastOptions& options = checked_cast<const CastState&>(*ctx->state()).options;
+Status BinaryToBinaryCastExec(KernelContext* ctx, const ExecSpan& batch,
+                              ExecResult* out) {
   const ArraySpan& input = batch[0].array;
 
-  if (!I::is_utf8 && O::is_utf8 && !options.allow_invalid_utf8) {
+  // This presupposes that one was created in the invocation layer
+  ArrayData* output = out->array_data().get();
+  output->SetNullCount(input.null_count);
+
+  const auto& options = CastState::Get(ctx);
+  bool check_utf8 = !I::is_utf8 && O::is_utf8 && !options.allow_invalid_utf8;
+  if (check_utf8) {
     InitializeUTF8();
-    ArraySpanVisitor<I> visitor;
-    Utf8Validator validator;
-    RETURN_NOT_OK(visitor.Visit(input, &validator));
   }
 
-  // Start with a zero-copy cast, but change indices to expected size
-  RETURN_NOT_OK(ZeroCopyCastExec(ctx, batch, out));
-  return CastBinaryToBinaryOffsets<typename I::offset_type, typename O::offset_type>(
-      ctx, input, out->array_data().get());
-}
+  [[maybe_unused]] auto SimpleUtf8Validation = [&] {
+    if (check_utf8) {
+      Utf8Validator validator;
+      return ArraySpanVisitor<I>::Visit(input, &validator);
+    }
+    return Status::OK();
+  };
 
-template <typename O, typename I>
-enable_if_t<std::is_same<I, FixedSizeBinaryType>::value &&
-                !std::is_same<O, FixedSizeBinaryType>::value,
-            Status>
-BinaryToBinaryCastExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
-  const CastOptions& options = checked_cast<const CastState&>(*ctx->state()).options;
-  const ArraySpan& input = batch[0].array;
+  constexpr bool kInputOffsets =
+      std::is_base_of_v<BinaryType, I> || std::is_base_of_v<LargeBinaryType, I>;
 
-  if (O::is_utf8 && !options.allow_invalid_utf8) {
-    InitializeUTF8();
-    ArraySpanVisitor<I> visitor;
-    Utf8Validator validator;
-    RETURN_NOT_OK(visitor.Visit(input, &validator));
+  constexpr bool kInputViews = std::is_base_of_v<BinaryViewType, I>;
+
+  constexpr bool kInputFixed = std::is_same_v<FixedSizeBinaryType, I>;
+
+  constexpr bool kOutputOffsets =
+      std::is_base_of_v<BinaryType, O> || std::is_base_of_v<LargeBinaryType, O>;
+
+  constexpr bool kOutputViews = std::is_base_of_v<BinaryViewType, O>;
+
+  constexpr bool kOutputFixed = std::is_same_v<FixedSizeBinaryType, O>;
+
+  if constexpr (kInputOffsets && kOutputOffsets) {
+    // Start with a zero-copy cast, but change indices to expected size
+    RETURN_NOT_OK(SimpleUtf8Validation());
+    RETURN_NOT_OK(ZeroCopyCastExec(ctx, batch, out));
+    // FIXME(bkietz) this discards preallocated storage. It seems preferable to me to
+    // allocate a new null bitmap if necessary than to always allocate new offsets.
+    return CastBinaryToBinaryOffsets<typename I::offset_type, typename O::offset_type>(
+        ctx, input, out->array_data().get());
   }
 
-  // Check for overflow
-  using output_offset_type = typename O::offset_type;
-  constexpr output_offset_type kMaxOffset =
-      std::numeric_limits<output_offset_type>::max();
-  const int32_t width = input.type->byte_width();
-  const int64_t max_offset = width * input.length;
-  if (max_offset > kMaxOffset) {
-    return Status::Invalid("Failed casting from ", input.type->ToString(), " to ",
-                           out->type()->ToString(), ": input array too large");
+  if constexpr (kInputViews && kOutputViews) {
+    return SimpleUtf8Validation() & ZeroCopyCastExec(ctx, batch, out);
   }
 
-  // This presupposes that one was created in the invocation layer
-  ArrayData* output = out->array_data().get();
+  if constexpr (kInputViews && kOutputOffsets) {
+    if (input.MayHaveNulls()) {
+      ARROW_ASSIGN_OR_RAISE(
+          output->buffers[0],
+          arrow::internal::CopyBitmap(ctx->memory_pool(), input.buffers[0].data,
+                                      input.offset, input.length));
+    } else {
+      output->buffers[0] = nullptr;
+    }
 
-  // Copy buffers over, then generate indices
-  output->length = input.length;
-  output->SetNullCount(input.null_count);
-  if (input.offset == output->offset) {
-    output->buffers[0] = input.GetBuffer(0);
-  } else {
-    ARROW_ASSIGN_OR_RAISE(
-        output->buffers[0],
-        arrow::internal::CopyBitmap(ctx->memory_pool(), input.buffers[0].data,
-                                    input.offset, input.length));
-  }
+    using offset_type = typename O::offset_type;
+
+    auto* offset = output->buffers[1]->mutable_data_as<offset_type>();
+    offset[0] = 0;
+
+    util::span char_buffers{
+        reinterpret_cast<const std::shared_ptr<Buffer>*>(input.buffers[2].data),
+        static_cast<size_t>(input.buffers[2].size / sizeof(std::shared_ptr<Buffer>))};
+    int64_t char_count = 0;
+    for (const auto& buf : char_buffers) {
+      char_count += buf->size();
+    }
+    BufferBuilder char_builder{ctx->memory_pool()};
+    RETURN_NOT_OK(char_builder.Reserve(char_count));
+
+    RETURN_NOT_OK(VisitArraySpanInline<StringViewType>(
+        input,
+        [&](std::string_view v) {
+          if constexpr (std::is_same_v<offset_type, int32_t>) {
+            if (ARROW_PREDICT_FALSE(
+                    char_builder.length() + v.size() >
+                    static_cast<size_t>(std::numeric_limits<int32_t>::max()))) {
+              return Status::Invalid("Failed casting from ", input.type->ToString(),
+                                     " to ", out->type()->ToString(),
+                                     ": input array viewed too many characters");
+            }
+          }
+          offset[1] = static_cast<offset_type>(offset[0] + v.size());
+          ++offset;
+          return char_builder.Append(v);
+        },
+        [&] {
+          offset[1] = offset[0];
+          ++offset;
+          return Status::OK();
+        }));
 
-  // This buffer is preallocated
-  output_offset_type* offsets = output->GetMutableValues<output_offset_type>(1);
-  offsets[0] = static_cast<output_offset_type>(input.offset * width);
-  for (int64_t i = 0; i < input.length; i++) {
-    offsets[i + 1] = offsets[i] + width;
+    RETURN_NOT_OK(SimpleUtf8Validation());
+    return char_builder.Finish(&output->buffers[2]);
   }
 
-  // Data buffer (index 1) for FWBinary becomes data buffer for VarBinary
-  // (index 2). After ARROW-16757, we need to copy this memory instead of
-  // zero-copy it because a Scalar value promoted to an ArraySpan may be
-  // referencing a temporary buffer whose scope does not extend beyond the
-  // kernel execution. In that scenario, the validity bitmap above can be
-  // zero-copied because it points to static memory (either a byte with a 1 or
-  // a 0 depending on whether the value is null or not).
-  std::shared_ptr<Buffer> input_data = input.GetBuffer(1);
-  if (input_data != nullptr) {
-    ARROW_ASSIGN_OR_RAISE(output->buffers[2], input_data->CopySlice(0, input_data->size(),
-                                                                    ctx->memory_pool()));
-  } else {
-    // TODO(wesm): it should already be nullptr, so we may be able to remove
-    // this
-    output->buffers[2] = nullptr;
+  if constexpr ((kInputOffsets || kInputFixed) && kOutputViews) {
+    // TODO(bkietz) when outputting views, we *could* output into slices,
+    // provided we have a threadsafe place to stash accumulated buffers
+    // of character data.
+    if (input.MayHaveNulls()) {
+      ARROW_ASSIGN_OR_RAISE(
+          output->buffers[0],
+          arrow::internal::CopyBitmap(ctx->memory_pool(), input.buffers[0].data,
+                                      input.offset, input.length));
+    } else {
+      output->buffers[0] = nullptr;
+    }
+
+    // Borrow the input's character buffer
+    output->buffers.resize(3);
+    output->buffers[2] = input.GetBuffer(kInputFixed ? 1 : 2);
+    auto* buffer_data = output->buffers[2]->data_as<char>();
+
+    auto* headers = output->buffers[1]->mutable_data_as<StringHeader>();
+    if (check_utf8) {
+      Utf8Validator validator;
+      return VisitArraySpanInline<I>(
+          input,
+          [&](std::string_view v) {
+            new (headers++)
+                StringHeader{v.data(), static_cast<uint32_t>(v.size()), 0, buffer_data};
+            return validator.VisitValue(v);
+          },
+          [&] {
+            *headers++ = StringHeader{};
+            return Status::OK();
+          });
+    } else {
+      VisitArraySpanInline<I>(
+          input,
+          [&](std::string_view v) {
+            new (headers++)
+                StringHeader{v.data(), static_cast<uint32_t>(v.size()), 0, buffer_data};
+          },
+          [&] { *headers++ = StringHeader{}; });
+      return Status::OK();
+    }
   }
 
-  return Status::OK();
-}
+  if constexpr (kInputFixed && kOutputOffsets) {
+    RETURN_NOT_OK(SimpleUtf8Validation());
 
-template <typename O, typename I>
-enable_if_t<std::is_same<I, FixedSizeBinaryType>::value &&
-                std::is_same<O, FixedSizeBinaryType>::value,
-            Status>
-BinaryToBinaryCastExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
-  const CastOptions& options = checked_cast<const CastState&>(*ctx->state()).options;
-  const int32_t in_width = batch[0].type()->byte_width();
-  const int32_t out_width =
-      checked_cast<const FixedSizeBinaryType&>(*options.to_type).byte_width();
-  if (in_width != out_width) {
-    return Status::Invalid("Failed casting from ", batch[0].type()->ToString(), " to ",
-                           options.to_type.ToString(), ": widths must match");
+    using output_offset_type = typename O::offset_type;
+
+    int32_t width = input.type->byte_width();
+
+    if constexpr (std::is_same_v<output_offset_type, int32_t>) {
+      // Check for overflow
+      if (width * input.length > std::numeric_limits<int32_t>::max()) {
+        return Status::Invalid("Failed casting from ", input.type->ToString(), " to ",
+                               out->type()->ToString(), ": input array too large");
+      }
+    }
+
+    // Copy buffers over, then generate indices
+    output->length = input.length;
+    output->SetNullCount(input.null_count);
+    if (input.offset == output->offset) {
+      output->buffers[0] = input.GetBuffer(0);
+    } else {
+      ARROW_ASSIGN_OR_RAISE(
+          output->buffers[0],
+          arrow::internal::CopyBitmap(ctx->memory_pool(), input.buffers[0].data,
+                                      input.offset, input.length));
+    }
+
+    // This buffer is preallocated
+    auto* offsets = output->buffers[1]->mutable_data_as<output_offset_type>();
+    offsets[0] = static_cast<output_offset_type>(input.offset * width);
+    for (int64_t i = 0; i < input.length; i++) {
+      offsets[i + 1] = offsets[i] + width;
+    }
+
+    // Data buffer (index 1) for FWBinary becomes data buffer for VarBinary
+    // (index 2). After ARROW-16757, we need to copy this memory instead of
+    // zero-copy it because a Scalar value promoted to an ArraySpan may be
+    // referencing a temporary buffer whose scope does not extend beyond the
+    // kernel execution. In that scenario, the validity bitmap above can be
+    // zero-copied because it points to static memory (either a byte with a 1 or
+    // a 0 depending on whether the value is null or not).
+    if (std::shared_ptr<Buffer> input_data = input.GetBuffer(1)) {
+      ARROW_ASSIGN_OR_RAISE(
+          output->buffers[2],
+          input_data->CopySlice(0, input_data->size(), ctx->memory_pool()));
+    } else {
+      // TODO(wesm): it should already be nullptr, so we may be able to remove
+      // this
+      output->buffers[2] = nullptr;
+    }
+
+    return Status::OK();
+  }
+
+  if constexpr (kInputFixed && kOutputFixed) {
+    if (input.type->byte_width() != output->type->byte_width()) {
+      return Status::Invalid("Failed casting from ", input.type->ToString(), " to ",
+                             output->type->ToString(), ": widths must match");
+    }
+    return ZeroCopyCastExec(ctx, batch, out);
   }
-  return ZeroCopyCastExec(ctx, batch, out);
+
+  Unreachable();
 }
 
 #if defined(_MSC_VER)
@@ -447,6 +556,8 @@ template <typename OutType>
 void AddBinaryToBinaryCast(CastFunction* func) {
   AddBinaryToBinaryCast<OutType, StringType>(func);
   AddBinaryToBinaryCast<OutType, BinaryType>(func);
+  AddBinaryToBinaryCast<OutType, StringViewType>(func);
+  AddBinaryToBinaryCast<OutType, BinaryViewType>(func);
   AddBinaryToBinaryCast<OutType, LargeStringType>(func);
   AddBinaryToBinaryCast<OutType, LargeBinaryType>(func);
   AddBinaryToBinaryCast<OutType, FixedSizeBinaryType>(func);
@@ -459,6 +570,11 @@ std::vector<std::shared_ptr<CastFunction>> GetBinaryLikeCasts() {
   AddCommonCasts(Type::BINARY, binary(), cast_binary.get());
   AddBinaryToBinaryCast<BinaryType>(cast_binary.get());
 
+  auto cast_binary_view =
+      std::make_shared<CastFunction>("cast_binary_view", Type::BINARY_VIEW);
+  AddCommonCasts(Type::BINARY_VIEW, binary_view(), cast_binary_view.get());
+  AddBinaryToBinaryCast<BinaryViewType>(cast_binary_view.get());
+
   auto cast_large_binary =
       std::make_shared<CastFunction>("cast_large_binary", Type::LARGE_BINARY);
   AddCommonCasts(Type::LARGE_BINARY, large_binary(), cast_large_binary.get());
@@ -471,6 +587,14 @@ std::vector<std::shared_ptr<CastFunction>> GetBinaryLikeCasts() {
   AddTemporalToStringCasts<StringType>(cast_string.get());
   AddBinaryToBinaryCast<StringType>(cast_string.get());
 
+  auto cast_string_view =
+      std::make_shared<CastFunction>("cast_string_view", Type::STRING_VIEW);
+  AddCommonCasts(Type::STRING_VIEW, utf8_view(), cast_string_view.get());
+  AddNumberToStringCasts<StringViewType>(cast_string_view.get());
+  AddDecimalToStringCasts<StringViewType>(cast_string_view.get());
+  AddTemporalToStringCasts<StringViewType>(cast_string_view.get());
+  AddBinaryToBinaryCast<StringViewType>(cast_string_view.get());
+
   auto cast_large_string =
       std::make_shared<CastFunction>("cast_large_string", Type::LARGE_STRING);
   AddCommonCasts(Type::LARGE_STRING, large_utf8(), cast_large_string.get());
@@ -481,17 +605,17 @@ std::vector<std::shared_ptr<CastFunction>> GetBinaryLikeCasts() {
 
   auto cast_fsb =
       std::make_shared<CastFunction>("cast_fixed_size_binary", Type::FIXED_SIZE_BINARY);
-  AddCommonCasts(Type::FIXED_SIZE_BINARY, OutputType(ResolveOutputFromOptions),
-                 cast_fsb.get());
+  AddCommonCasts(Type::FIXED_SIZE_BINARY, kOutputTargetType, cast_fsb.get());
   DCHECK_OK(cast_fsb->AddKernel(
-      Type::FIXED_SIZE_BINARY, {InputType(Type::FIXED_SIZE_BINARY)},
-      OutputType(FirstType),
+      Type::FIXED_SIZE_BINARY, {InputType(Type::FIXED_SIZE_BINARY)}, kOutputTargetType,
       BinaryToBinaryCastExec<FixedSizeBinaryType, FixedSizeBinaryType>,
       NullHandling::COMPUTED_NO_PREALLOCATE));
 
-  return {cast_binary, cast_large_binary, cast_string, cast_large_string, cast_fsb};
+  return {
+      cast_binary,      cast_binary_view,  cast_large_binary, cast_string,
+      cast_string_view, cast_large_string, cast_fsb,
+  };
 }
 
-}  // namespace internal
-}  // namespace compute
+}  // namespace compute::internal
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
index 083a85eb346..5384008b1b7 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
@@ -145,7 +145,7 @@ static std::shared_ptr<Array> MaskArrayWithNullsAt(std::shared_ptr<Array> input,
 
   using arrow::internal::Bitmap;
   Bitmap is_valid(masked->buffers[0], 0, input->length());
-  if (auto original = input->null_bitmap()) {
+  if (const auto& original = input->null_bitmap()) {
     is_valid.CopyFrom(Bitmap(original, input->offset(), input->length()));
   } else {
     is_valid.SetBitsTo(true);
@@ -154,7 +154,7 @@ static std::shared_ptr<Array> MaskArrayWithNullsAt(std::shared_ptr<Array> input,
   for (int i : indices_to_mask) {
     is_valid.SetBitTo(i, false);
   }
-  return MakeArray(masked);
+  return MakeArray(std::move(masked));
 }
 
 TEST(Cast, CanCast) {
@@ -167,6 +167,9 @@ TEST(Cast, CanCast) {
     }
   };
 
+  ExpectCanCast(boolean(), {utf8()});
+  return;
+
   auto ExpectCannotCast = [ExpectCanCast](std::shared_ptr<DataType> from,
                                           std::vector<std::shared_ptr<DataType>> to_set) {
     ExpectCanCast(from, to_set, /*expected=*/false);
@@ -198,17 +201,21 @@ TEST(Cast, CanCast) {
     ExpectCannotCast(from_numeric, {null()});
   }
 
-  for (auto from_base_binary : kBaseBinaryTypes) {
-    ExpectCanCast(from_base_binary, {boolean()});
-    ExpectCanCast(from_base_binary, kNumericTypes);
-    ExpectCanCast(from_base_binary, kBaseBinaryTypes);
-    ExpectCanCast(dictionary(int64(), from_base_binary), {from_base_binary});
+  auto base_binary_and_view_types = kBaseBinaryTypes;
+  base_binary_and_view_types.push_back(binary_view());
+  base_binary_and_view_types.push_back(utf8_view());
+
+  for (auto from : base_binary_and_view_types) {
+    ExpectCanCast(from, {boolean()});
+    ExpectCanCast(from, kNumericTypes);
+    ExpectCanCast(from, base_binary_and_view_types);
+    ExpectCanCast(dictionary(int64(), from), {from});
 
     // any cast which is valid for the dictionary is valid for the DictionaryArray
-    ExpectCanCast(dictionary(uint32(), from_base_binary), kBaseBinaryTypes);
-    ExpectCanCast(dictionary(int16(), from_base_binary), kNumericTypes);
+    ExpectCanCast(dictionary(uint32(), from), kBaseBinaryTypes);
+    ExpectCanCast(dictionary(int16(), from), kNumericTypes);
 
-    ExpectCannotCast(from_base_binary, {null()});
+    ExpectCannotCast(from, {null()});
   }
 
   ExpectCanCast(utf8(), {timestamp(TimeUnit::MILLI)});
@@ -1029,7 +1036,7 @@ TEST(Cast, DecimalToFloating) {
 }
 
 TEST(Cast, DecimalToString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     for (auto decimal_type : {decimal128(5, 2), decimal256(5, 2)}) {
       CheckCast(ArrayFromJSON(decimal_type, R"(["0.00", null, "123.45", "999.99"])"),
                 ArrayFromJSON(string_type, R"(["0.00", null, "123.45", "999.99"])"));
@@ -1548,7 +1555,7 @@ TEST(Cast, TimeZeroCopy) {
 }
 
 TEST(Cast, DateToString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     CheckCast(ArrayFromJSON(date32(), "[0, null]"),
               ArrayFromJSON(string_type, R"(["1970-01-01", null])"));
     CheckCast(ArrayFromJSON(date64(), "[86400000, null]"),
@@ -1557,7 +1564,7 @@ TEST(Cast, DateToString) {
 }
 
 TEST(Cast, TimeToString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     CheckCast(ArrayFromJSON(time32(TimeUnit::SECOND), "[1, 62]"),
               ArrayFromJSON(string_type, R"(["00:00:01", "00:01:02"])"));
     CheckCast(
@@ -1567,7 +1574,7 @@ TEST(Cast, TimeToString) {
 }
 
 TEST(Cast, TimestampToString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     CheckCast(
         ArrayFromJSON(timestamp(TimeUnit::SECOND), "[-30610224000, -5364662400]"),
         ArrayFromJSON(string_type, R"(["1000-01-01 00:00:00", "1800-01-01 00:00:00"])"));
@@ -1593,7 +1600,7 @@ TEST(Cast, TimestampToString) {
 }
 
 TEST_F(CastTimezone, TimestampWithZoneToString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     CheckCast(
         ArrayFromJSON(timestamp(TimeUnit::SECOND, "UTC"), "[-30610224000, -5364662400]"),
         ArrayFromJSON(string_type,
@@ -1779,7 +1786,7 @@ TEST(Cast, DurationToDurationMultiplyOverflow) {
 }
 
 TEST(Cast, DurationToString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     for (auto unit : TimeUnit::values()) {
       CheckCast(ArrayFromJSON(duration(unit), "[0, null, 1234567, 2000]"),
                 ArrayFromJSON(string_type, R"(["0", null, "1234567", "2000"])"));
@@ -2016,6 +2023,10 @@ TEST(Cast, StringToTimestamp) {
 }
 
 static void AssertBinaryZeroCopy(std::shared_ptr<Array> lhs, std::shared_ptr<Array> rhs) {
+  for (auto id : {lhs->type_id(), rhs->type_id()}) {
+    // views cannot be zero copied
+    if (id == Type::BINARY_VIEW || id == Type::STRING_VIEW) return;
+  }
   // null bitmap and data buffers are always zero-copied
   AssertBufferSame(*lhs, *rhs, 0);
   AssertBufferSame(*lhs, *rhs, 2);
@@ -2039,8 +2050,9 @@ static void AssertBinaryZeroCopy(std::shared_ptr<Array> lhs, std::shared_ptr<Arr
 }
 
 TEST(Cast, BinaryToString) {
-  for (auto bin_type : {binary(), large_binary()}) {
-    for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto bin_type : {binary(), large_binary(), binary_view()}) {
+    for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
+      ARROW_SCOPED_TRACE(*bin_type, " to ", *string_type);
       // empty -> empty always works
       CheckCast(ArrayFromJSON(bin_type, "[]"), ArrayFromJSON(string_type, "[]"));
 
@@ -2058,13 +2070,14 @@ TEST(Cast, BinaryToString) {
       options.allow_invalid_utf8 = true;
       ASSERT_OK_AND_ASSIGN(auto strings, Cast(*invalid_utf8, string_type, options));
       ASSERT_RAISES(Invalid, strings->ValidateFull());
+
       AssertBinaryZeroCopy(invalid_utf8, strings);
     }
   }
 
   auto from_type = fixed_size_binary(3);
   auto invalid_utf8 = FixedSizeInvalidUtf8(from_type);
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     CheckCast(ArrayFromJSON(from_type, "[]"), ArrayFromJSON(string_type, "[]"));
 
     // invalid utf-8 masked by a null bit is not an error
@@ -2083,9 +2096,12 @@ TEST(Cast, BinaryToString) {
     // N.B. null buffer is not always the same if input sliced
     AssertBufferSame(*invalid_utf8, *strings, 0);
 
-    // ARROW-16757: we no longer zero copy, but the contents are equal
-    ASSERT_NE(invalid_utf8->data()->buffers[1].get(), strings->data()->buffers[2].get());
-    ASSERT_TRUE(invalid_utf8->data()->buffers[1]->Equals(*strings->data()->buffers[2]));
+    if (string_type->id() != Type::STRING_VIEW) {
+      // ARROW-16757: we no longer zero copy, but the contents are equal
+      ASSERT_NE(invalid_utf8->data()->buffers[1].get(),
+                strings->data()->buffers[2].get());
+      ASSERT_TRUE(invalid_utf8->data()->buffers[1]->Equals(*strings->data()->buffers[2]));
+    }
   }
 }
 
@@ -2154,7 +2170,7 @@ TEST(Cast, StringToString) {
 }
 
 TEST(Cast, IntToString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     CheckCast(ArrayFromJSON(int8(), "[0, 1, 127, -128, null]"),
               ArrayFromJSON(string_type, R"(["0", "1", "127", "-128", null])"));
 
@@ -2186,7 +2202,7 @@ TEST(Cast, IntToString) {
 }
 
 TEST(Cast, FloatingToString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     CheckCast(
         ArrayFromJSON(float32(), "[0.0, -0.0, 1.5, -Inf, Inf, NaN, null]"),
         ArrayFromJSON(string_type, R"(["0", "-0", "1.5", "-inf", "inf", "nan", null])"));
@@ -2198,7 +2214,7 @@ TEST(Cast, FloatingToString) {
 }
 
 TEST(Cast, BooleanToString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     CheckCast(ArrayFromJSON(boolean(), "[true, true, false, null]"),
               ArrayFromJSON(string_type, R"(["true", "true", "false", null])"));
   }
diff --git a/cpp/src/arrow/compute/kernels/scalar_nested_test.cc b/cpp/src/arrow/compute/kernels/scalar_nested_test.cc
index a72ec99620b..44d3f3a447c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_nested_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_nested_test.cc
@@ -862,6 +862,9 @@ TEST(MakeStruct, Array) {
   EXPECT_THAT(MakeStructor({i32, str}, {"i", "s"}),
               ResultWith(Datum(*StructArray::Make({i32, str}, field_names))));
 
+  EXPECT_THAT(*MakeScalar("aa"), testing::Eq(StringScalar("aa")));
+  EXPECT_EQ(*MakeStructor({i32, MakeScalar("aa")}, {"i", "s"})->type(),
+            StructType({field("i", i32->type()), field("s", str->type())}));
   // Scalars are broadcast to the length of the arrays
   EXPECT_THAT(MakeStructor({i32, MakeScalar("aa")}, {"i", "s"}),
               ResultWith(Datum(*StructArray::Make({i32, str}, field_names))));
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 4581e6377a7..50daec6cbaa 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -48,7 +48,6 @@ namespace compute {
 template <typename TestType>
 class BaseTestStringKernels : public ::testing::Test {
  protected:
-  using OffsetType = typename TypeTraits<TestType>::OffsetType;
   using ScalarType = typename TypeTraits<TestType>::ScalarType;
 
   void CheckUnary(std::string func_name, std::string json_input,
@@ -98,7 +97,14 @@ class BaseTestStringKernels : public ::testing::Test {
   }
 
   std::shared_ptr<DataType> offset_type() {
-    return TypeTraits<OffsetType>::type_singleton();
+    if constexpr (is_binary_view_like_type<TestType>::value) {
+      // Views do not have offsets, but Functions like binary_length
+      // will return the length as uint32
+      return uint32();
+    } else {
+      using OffsetType = typename TypeTraits<TestType>::OffsetType;
+      return TypeTraits<OffsetType>::type_singleton();
+    }
   }
 
   template <typename CType = const char*>
diff --git a/cpp/src/arrow/compute/kernels/vector_array_sort.cc b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
index 1499554a960..07fd0a4e27c 100644
--- a/cpp/src/arrow/compute/kernels/vector_array_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
@@ -33,6 +33,7 @@
 #include "arrow/util/bitmap.h"
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/unreachable.h"
 #include "arrow/visit_type_inline.h"
 
 namespace arrow {
@@ -77,14 +78,35 @@ struct PartitionNthToIndices {
     }
     const auto p = PartitionNulls<ArrayType, NonStablePartitioner>(
         out_begin, out_end, arr, 0, options.null_placement);
+
     auto nth_begin = out_begin + pivot;
     if (nth_begin >= p.non_nulls_begin && nth_begin < p.non_nulls_end) {
-      std::nth_element(p.non_nulls_begin, nth_begin, p.non_nulls_end,
-                       [&arr](uint64_t left, uint64_t right) {
-                         const auto lval = GetView::LogicalValue(arr.GetView(left));
-                         const auto rval = GetView::LogicalValue(arr.GetView(right));
-                         return lval < rval;
-                       });
+      if constexpr (is_binary_view_like_type<InType>::value) {
+        const StringHeader* headers = arr.raw_values();
+        const auto* char_buffers = arr.data()->buffers.data() + 2;
+
+        auto Partition = [&](auto has_raw_pointers) {
+          std::nth_element(p.non_nulls_begin, nth_begin, p.non_nulls_end,
+                           [&](uint64_t left, uint64_t right) {
+                             const auto& lval = headers[left];
+                             const auto& rval = headers[right];
+                             if constexpr (has_raw_pointers.value) return lval < rval;
+                             // we must compare the views in place with the array's
+                             // character buffers
+                             return lval.LessThanIndexOffset(char_buffers, rval,
+                                                             char_buffers);
+                           });
+        };
+        arr.has_raw_pointers() ? Partition(/*has_raw_pointers=*/std::true_type{})
+                               : Partition(/*has_raw_pointers=*/std::false_type{});
+      } else {
+        std::nth_element(p.non_nulls_begin, nth_begin, p.non_nulls_end,
+                         [&arr](uint64_t left, uint64_t right) {
+                           const auto lval = GetView::LogicalValue(arr.GetView(left));
+                           const auto rval = GetView::LogicalValue(arr.GetView(right));
+                           return lval < rval;
+                         });
+      }
     }
     return Status::OK();
   }
@@ -173,6 +195,53 @@ class ArrayCompareSorter {
   }
 };
 
+template <>
+class ArrayCompareSorter<BinaryViewType> {
+ public:
+  Result<NullPartitionResult> operator()(uint64_t* indices_begin, uint64_t* indices_end,
+                                         const Array& array, int64_t offset,
+                                         const ArraySortOptions& options, ExecContext*) {
+    const auto& values = checked_cast<const BinaryViewArray&>(array);
+    const StringHeader* headers = values.raw_values();
+
+    const auto p = PartitionNulls<BinaryViewArray, StablePartitioner>(
+        indices_begin, indices_end, values, offset, options.null_placement);
+    const auto* char_buffers = values.data()->buffers.data() + 2;
+
+    auto Sort = [&](auto has_raw_pointers, auto ascending) {
+      std::stable_sort(
+          p.non_nulls_begin, p.non_nulls_end, [&](uint64_t left, uint64_t right) {
+            const auto& lhs = headers[left - offset];
+            const auto& rhs = headers[right - offset];
+
+            if constexpr (has_raw_pointers.value) {
+              if constexpr (ascending.value) return lhs < rhs;
+              if constexpr (!ascending.value) return rhs < lhs;
+            }
+
+            // we must compare the views in place with the array's
+            // character buffers
+            if constexpr (ascending.value) {
+              return lhs.LessThanIndexOffset(char_buffers, rhs, char_buffers);
+            } else {
+              return rhs.LessThanIndexOffset(char_buffers, lhs, char_buffers);
+            }
+          });
+    };
+
+    if (options.order == SortOrder::Ascending) {
+      values.has_raw_pointers()
+          ? Sort(/*has_raw_pointers=*/std::true_type{}, /*ascending=*/std::true_type{})
+          : Sort(/*has_raw_pointers=*/std::false_type{}, /*ascending=*/std::true_type{});
+    } else {
+      values.has_raw_pointers()
+          ? Sort(/*has_raw_pointers=*/std::true_type{}, /*ascending=*/std::false_type{})
+          : Sort(/*has_raw_pointers=*/std::false_type{}, /*ascending=*/std::false_type{});
+    }
+    return p;
+  }
+};
+
 template <>
 class ArrayCompareSorter<DictionaryType> {
  public:
@@ -501,6 +570,11 @@ struct ArraySorter<
   ArrayCompareSorter<Type> impl;
 };
 
+template <>
+struct ArraySorter<BinaryViewType> {
+  ArrayCompareSorter<BinaryViewType> impl;
+};
+
 struct ArraySorterFactory {
   ArraySortFunc sorter;
 
@@ -594,6 +668,15 @@ void AddArraySortingKernels(VectorKernel base, VectorFunction* func) {
     base.exec = GenerateVarBinaryBase<ExecTemplate, UInt64Type>(*physical_type);
     DCHECK_OK(func->AddKernel(base));
   }
+
+  base.signature = KernelSignature::Make({utf8_view()}, uint64());
+  base.exec = ExecTemplate<UInt64Type, StringViewType>::Exec;
+  DCHECK_OK(func->AddKernel(base));
+
+  base.signature = KernelSignature::Make({binary_view()}, uint64());
+  base.exec = ExecTemplate<UInt64Type, BinaryViewType>::Exec;
+  DCHECK_OK(func->AddKernel(base));
+
   base.signature = KernelSignature::Make({Type::FIXED_SIZE_BINARY}, uint64());
   base.exec = ExecTemplate<UInt64Type, FixedSizeBinaryType>::Exec;
   DCHECK_OK(func->AddKernel(base));
diff --git a/cpp/src/arrow/compute/kernels/vector_hash.cc b/cpp/src/arrow/compute/kernels/vector_hash.cc
index 2eab7ae8afa..9f20b640271 100644
--- a/cpp/src/arrow/compute/kernels/vector_hash.cc
+++ b/cpp/src/arrow/compute/kernels/vector_hash.cc
@@ -30,6 +30,7 @@
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/result.h"
 #include "arrow/util/hashing.h"
+#include "arrow/util/unreachable.h"
 
 namespace arrow {
 
@@ -261,7 +262,7 @@ class HashKernel : public KernelState {
 // Base class for all "regular" hash kernel implementations
 // (NullType has a separate implementation)
 
-template <typename Type, typename Scalar, typename Action,
+template <typename Type, typename Action, typename Scalar = typename Type::c_type,
           bool with_error_status = Action::with_error_status>
 class RegularHashKernel : public HashKernel {
  public:
@@ -501,39 +502,13 @@ class DictionaryHashKernel : public HashKernel {
 };
 
 // ----------------------------------------------------------------------
-
-template <typename Type, typename Action, typename Enable = void>
-struct HashKernelTraits {};
-
-template <typename Type, typename Action>
-struct HashKernelTraits<Type, Action, enable_if_null<Type>> {
-  using HashKernel = NullHashKernel<Action>;
-};
-
-template <typename Type, typename Action>
-struct HashKernelTraits<Type, Action, enable_if_has_c_type<Type>> {
-  using HashKernel = RegularHashKernel<Type, typename Type::c_type, Action>;
-};
-
-template <typename Type, typename Action>
-struct HashKernelTraits<Type, Action, enable_if_has_string_view<Type>> {
-  using HashKernel = RegularHashKernel<Type, std::string_view, Action>;
-};
-
-template <typename Type, typename Action>
-Result<std::unique_ptr<HashKernel>> HashInitImpl(KernelContext* ctx,
-                                                 const KernelInitArgs& args) {
-  using HashKernelType = typename HashKernelTraits<Type, Action>::HashKernel;
-  auto result = std::make_unique<HashKernelType>(args.inputs[0].GetSharedPtr(),
-                                                 args.options, ctx->memory_pool());
-  RETURN_NOT_OK(result->Reset());
-  return std::move(result);
-}
-
-template <typename Type, typename Action>
+template <typename HashKernel>
 Result<std::unique_ptr<KernelState>> HashInit(KernelContext* ctx,
                                               const KernelInitArgs& args) {
-  return HashInitImpl<Type, Action>(ctx, args);
+  auto result = std::make_unique<HashKernel>(args.inputs[0].GetSharedPtr(), args.options,
+                                             ctx->memory_pool());
+  RETURN_NOT_OK(result->Reset());
+  return std::move(result);
 }
 
 template <typename Action>
@@ -542,22 +517,22 @@ KernelInit GetHashInit(Type::type type_id) {
   // representation
   switch (type_id) {
     case Type::NA:
-      return HashInit<NullType, Action>;
+      return HashInit<NullHashKernel<Action>>;
     case Type::BOOL:
-      return HashInit<BooleanType, Action>;
+      return HashInit<RegularHashKernel<BooleanType, Action>>;
     case Type::INT8:
     case Type::UINT8:
-      return HashInit<UInt8Type, Action>;
+      return HashInit<RegularHashKernel<UInt8Type, Action>>;
     case Type::INT16:
     case Type::UINT16:
-      return HashInit<UInt16Type, Action>;
+      return HashInit<RegularHashKernel<UInt16Type, Action>>;
     case Type::INT32:
     case Type::UINT32:
     case Type::FLOAT:
     case Type::DATE32:
     case Type::TIME32:
     case Type::INTERVAL_MONTHS:
-      return HashInit<UInt32Type, Action>;
+      return HashInit<RegularHashKernel<UInt32Type, Action>>;
     case Type::INT64:
     case Type::UINT64:
     case Type::DOUBLE:
@@ -566,22 +541,23 @@ KernelInit GetHashInit(Type::type type_id) {
     case Type::TIMESTAMP:
     case Type::DURATION:
     case Type::INTERVAL_DAY_TIME:
-      return HashInit<UInt64Type, Action>;
+      return HashInit<RegularHashKernel<UInt64Type, Action>>;
     case Type::BINARY:
     case Type::STRING:
-      return HashInit<BinaryType, Action>;
+    case Type::BINARY_VIEW:
+    case Type::STRING_VIEW:
+      return HashInit<RegularHashKernel<BinaryType, Action, std::string_view>>;
     case Type::LARGE_BINARY:
     case Type::LARGE_STRING:
-      return HashInit<LargeBinaryType, Action>;
+      return HashInit<RegularHashKernel<LargeBinaryType, Action, std::string_view>>;
     case Type::FIXED_SIZE_BINARY:
     case Type::DECIMAL128:
     case Type::DECIMAL256:
-      return HashInit<FixedSizeBinaryType, Action>;
+      return HashInit<RegularHashKernel<FixedSizeBinaryType, Action, std::string_view>>;
     case Type::INTERVAL_MONTH_DAY_NANO:
-      return HashInit<MonthDayNanoIntervalType, Action>;
+      return HashInit<RegularHashKernel<MonthDayNanoIntervalType, Action>>;
     default:
-      DCHECK(false);
-      return nullptr;
+      Unreachable("non hashable type");
   }
 }
 
@@ -591,31 +567,11 @@ template <typename Action>
 Result<std::unique_ptr<KernelState>> DictionaryHashInit(KernelContext* ctx,
                                                         const KernelInitArgs& args) {
   const auto& dict_type = checked_cast<const DictionaryType&>(*args.inputs[0].type);
-  Result<std::unique_ptr<HashKernel>> indices_hasher;
-  switch (dict_type.index_type()->id()) {
-    case Type::INT8:
-    case Type::UINT8:
-      indices_hasher = HashInitImpl<UInt8Type, Action>(ctx, args);
-      break;
-    case Type::INT16:
-    case Type::UINT16:
-      indices_hasher = HashInitImpl<UInt16Type, Action>(ctx, args);
-      break;
-    case Type::INT32:
-    case Type::UINT32:
-      indices_hasher = HashInitImpl<UInt32Type, Action>(ctx, args);
-      break;
-    case Type::INT64:
-    case Type::UINT64:
-      indices_hasher = HashInitImpl<UInt64Type, Action>(ctx, args);
-      break;
-    default:
-      DCHECK(false) << "Unsupported dictionary index type";
-      break;
-  }
-  RETURN_NOT_OK(indices_hasher);
-  return std::make_unique<DictionaryHashKernel>(std::move(indices_hasher.ValueOrDie()),
-                                                dict_type.value_type());
+  ARROW_ASSIGN_OR_RAISE(auto indices_hasher,
+                        GetHashInit<Action>(dict_type.index_type()->id())(ctx, args));
+  return std::make_unique<DictionaryHashKernel>(
+      checked_pointer_cast<HashKernel>(std::move(indices_hasher)),
+      dict_type.value_type());
 }
 
 Status HashExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
diff --git a/cpp/src/arrow/compute/kernels/vector_selection.cc b/cpp/src/arrow/compute/kernels/vector_selection.cc
index 64c3db204c9..d8b5d83fe9d 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection.cc
@@ -45,6 +45,8 @@
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/bitmap_reader.h"
 #include "arrow/util/int_util.h"
+#include "arrow/util/range.h"
+#include "arrow/util/span.h"
 
 namespace arrow {
 
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_benchmark.cc b/cpp/src/arrow/compute/kernels/vector_selection_benchmark.cc
index 25e30e65a35..5289b317110 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_benchmark.cc
@@ -26,8 +26,7 @@
 #include "arrow/testing/random.h"
 #include "arrow/util/benchmark_util.h"
 
-namespace arrow {
-namespace compute {
+namespace arrow::compute {
 
 constexpr auto kSeed = 0x0ff1ce;
 
@@ -135,6 +134,13 @@ struct TakeBenchmark {
     Bench(values);
   }
 
+  void StringView() {
+    int32_t string_min_length = 0, string_max_length = 32;
+    auto values = rand.StringView(args.size, string_min_length, string_max_length,
+                                  args.null_proportion);
+    Bench(values);
+  }
+
   void Bench(const std::shared_ptr<Array>& values) {
     double indices_null_proportion = indices_have_nulls ? args.null_proportion : 0;
     auto indices =
@@ -196,6 +202,21 @@ struct FilterBenchmark {
     Bench(values);
   }
 
+  void StringView() {
+    int32_t string_min_length = 0, string_max_length = 32;
+    int32_t string_mean_length = (string_max_length + string_min_length) / 2;
+    // for an array of 50% null strings, we need to generate twice as many strings
+    // to ensure that they have an average of args.size total characters
+    int64_t array_size = args.size;
+    if (args.values_null_proportion < 1) {
+      array_size = static_cast<int64_t>(args.size / string_mean_length /
+                                        (1 - args.values_null_proportion));
+    }
+    auto values = std::static_pointer_cast<StringViewArray>(rand.StringView(
+        array_size, string_min_length, string_max_length, args.values_null_proportion));
+    Bench(values);
+  }
+
   void Bench(const std::shared_ptr<Array>& values) {
     auto filter = rand.Boolean(values->length(), args.selected_proportion,
                                args.filter_null_proportion);
@@ -263,6 +284,14 @@ static void FilterStringFilterWithNulls(benchmark::State& state) {
   FilterBenchmark(state, true).String();
 }
 
+static void FilterStringViewFilterNoNulls(benchmark::State& state) {
+  FilterBenchmark(state, false).StringView();
+}
+
+static void FilterStringViewFilterWithNulls(benchmark::State& state) {
+  FilterBenchmark(state, true).StringView();
+}
+
 static void FilterRecordBatchNoNulls(benchmark::State& state) {
   FilterBenchmark(state, false).BenchRecordBatch();
 }
@@ -304,7 +333,19 @@ static void TakeStringRandomIndicesWithNulls(benchmark::State& state) {
 }
 
 static void TakeStringMonotonicIndices(benchmark::State& state) {
-  TakeBenchmark(state, /*indices_with_nulls=*/false, /*monotonic=*/true).FSLInt64();
+  TakeBenchmark(state, /*indices_with_nulls=*/false, /*monotonic=*/true).String();
+}
+
+static void TakeStringViewRandomIndicesNoNulls(benchmark::State& state) {
+  TakeBenchmark(state, false).StringView();
+}
+
+static void TakeStringViewRandomIndicesWithNulls(benchmark::State& state) {
+  TakeBenchmark(state, true).StringView();
+}
+
+static void TakeStringViewMonotonicIndices(benchmark::State& state) {
+  TakeBenchmark(state, /*indices_with_nulls=*/false, /*monotonic=*/true).StringView();
 }
 
 void FilterSetArgs(benchmark::internal::Benchmark* bench) {
@@ -321,6 +362,8 @@ BENCHMARK(FilterFSLInt64FilterNoNulls)->Apply(FilterSetArgs);
 BENCHMARK(FilterFSLInt64FilterWithNulls)->Apply(FilterSetArgs);
 BENCHMARK(FilterStringFilterNoNulls)->Apply(FilterSetArgs);
 BENCHMARK(FilterStringFilterWithNulls)->Apply(FilterSetArgs);
+BENCHMARK(FilterStringViewFilterNoNulls)->Apply(FilterSetArgs);
+BENCHMARK(FilterStringViewFilterWithNulls)->Apply(FilterSetArgs);
 
 void FilterRecordBatchSetArgs(benchmark::internal::Benchmark* bench) {
   for (auto num_cols : std::vector<int>({10, 50, 100})) {
@@ -349,6 +392,8 @@ BENCHMARK(TakeFSLInt64MonotonicIndices)->Apply(TakeSetArgs);
 BENCHMARK(TakeStringRandomIndicesNoNulls)->Apply(TakeSetArgs);
 BENCHMARK(TakeStringRandomIndicesWithNulls)->Apply(TakeSetArgs);
 BENCHMARK(TakeStringMonotonicIndices)->Apply(TakeSetArgs);
+BENCHMARK(TakeStringViewRandomIndicesNoNulls)->Apply(TakeSetArgs);
+BENCHMARK(TakeStringViewRandomIndicesWithNulls)->Apply(TakeSetArgs);
+BENCHMARK(TakeStringViewMonotonicIndices)->Apply(TakeSetArgs);
 
-}  // namespace compute
-}  // namespace arrow
+}  // namespace arrow::compute
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc b/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc
index ea9ee8a102e..d88f816efc7 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc
@@ -39,6 +39,8 @@
 #include "arrow/util/bit_run_reader.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bitmap_ops.h"
+#include "arrow/util/range.h"
+#include "arrow/util/span.h"
 
 namespace arrow {
 
@@ -149,12 +151,11 @@ class DropNullCounter {
 /// generate one take function for each byte width. We use the same
 /// implementation here for boolean and fixed-byte-size inputs with some
 /// template specialization.
-template <typename ArrowType>
+template <typename ArrowType,
+          typename T = std::conditional_t<std::is_same<ArrowType, BooleanType>::value,
+                                          uint8_t, typename ArrowType::c_type>>
 class PrimitiveFilterImpl {
  public:
-  using T = typename std::conditional<std::is_same<ArrowType, BooleanType>::value,
-                                      uint8_t, typename ArrowType::c_type>::type;
-
   PrimitiveFilterImpl(const ArraySpan& values, const ArraySpan& filter,
                       FilterOptions::NullSelectionBehavior null_selection,
                       ArrayData* out_arr)
@@ -206,7 +207,7 @@ class PrimitiveFilterImpl {
             } else {
               bit_util::SetBitsTo(out_is_valid_, out_offset_ + out_position_,
                                   segment_length, false);
-              memset(out_data_ + out_offset_ + out_position_, 0,
+              memset(static_cast<void*>(out_data_ + out_offset_ + out_position_), 0,
                      segment_length * sizeof(T));
               out_position_ += segment_length;
             }
@@ -228,7 +229,7 @@ class PrimitiveFilterImpl {
           } else {
             bit_util::SetBitsTo(out_is_valid_, out_offset_ + out_position_,
                                 segment_length, false);
-            memset(out_data_ + out_offset_ + out_position_, 0,
+            memset(static_cast<void*>(out_data_ + out_offset_ + out_position_), 0,
                    segment_length * sizeof(T));
             out_position_ += segment_length;
           }
@@ -536,7 +537,7 @@ Status BinaryFilterNonNullImpl(KernelContext* ctx, const ArraySpan& values,
     // Append offsets
     for (int64_t i = 0; i < length; ++i) {
       offset_builder.UnsafeAppend(offset);
-      offset += raw_offsets[i + position + 1] - raw_offsets[i + position + 1];
+      offset += raw_offsets[i + position + 1] - raw_offsets[i + position];
     }
     return Status::OK();
   };
@@ -824,6 +825,45 @@ Status BinaryFilterExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* o
   return Status::OK();
 }
 
+Status BinaryViewFilterExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+  const ArraySpan& values = batch[0].array;
+  const ArraySpan& filter = batch[1].array;
+  const bool is_ree_filter = filter.type->id() == Type::RUN_END_ENCODED;
+  FilterOptions::NullSelectionBehavior null_selection =
+      FilterState::Get(ctx).null_selection_behavior;
+
+  int64_t output_length = GetFilterOutputSize(filter, null_selection);
+
+  ArrayData* out_arr = out->array_data().get();
+
+  const bool filter_null_count_is_zero =
+      is_ree_filter ? filter.child_data[1].null_count == 0 : filter.null_count == 0;
+
+  // The output precomputed null count is unknown except in the narrow
+  // condition that all the values are non-null and the filter will not cause
+  // any new nulls to be created.
+  if (values.null_count == 0 &&
+      (null_selection == FilterOptions::DROP || filter_null_count_is_zero)) {
+    out_arr->null_count = 0;
+  } else {
+    out_arr->null_count = kUnknownNullCount;
+  }
+
+  // When neither the values nor filter is known to have any nulls, we will
+  // elect the optimized ExecNonNull path where there is no need to populate a
+  // validity bitmap.
+  const bool allocate_validity = values.null_count != 0 || !filter_null_count_is_zero;
+
+  RETURN_NOT_OK(PreallocatePrimitiveArrayData(
+      ctx, output_length, sizeof(StringHeader) * CHAR_BIT, allocate_validity, out_arr));
+
+  PrimitiveFilterImpl<BinaryViewType, StringHeader>(values, filter, null_selection,
+                                                    out_arr)
+      .Exec();
+  CloneBinaryViewCharacterBuffers(values, out_arr);
+  return Status::OK();
+}
+
 // ----------------------------------------------------------------------
 // Null filter
 
@@ -1037,6 +1077,7 @@ void PopulateFilterKernels(std::vector<SelectionKernelData>* out) {
       {InputType(match::Primitive()), plain_filter, PrimitiveFilterExec},
       {InputType(match::BinaryLike()), plain_filter, BinaryFilterExec},
       {InputType(match::LargeBinaryLike()), plain_filter, BinaryFilterExec},
+      {InputType(match::BinaryViewLike()), plain_filter, BinaryViewFilterExec},
       {InputType(Type::FIXED_SIZE_BINARY), plain_filter, FSBFilterExec},
       {InputType(null()), plain_filter, NullFilterExec},
       {InputType(Type::DECIMAL128), plain_filter, FSBFilterExec},
@@ -1054,6 +1095,7 @@ void PopulateFilterKernels(std::vector<SelectionKernelData>* out) {
       {InputType(match::Primitive()), ree_filter, PrimitiveFilterExec},
       {InputType(match::BinaryLike()), ree_filter, BinaryFilterExec},
       {InputType(match::LargeBinaryLike()), ree_filter, BinaryFilterExec},
+      {InputType(match::BinaryViewLike()), ree_filter, BinaryViewFilterExec},
       {InputType(Type::FIXED_SIZE_BINARY), ree_filter, FSBFilterExec},
       {InputType(null()), ree_filter, NullFilterExec},
       {InputType(Type::DECIMAL128), ree_filter, FSBFilterExec},
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_internal.cc b/cpp/src/arrow/compute/kernels/vector_selection_internal.cc
index 23b8b75bfa0..d205ef0fe33 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_internal.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_internal.cc
@@ -39,7 +39,9 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/int_util.h"
 #include "arrow/util/logging.h"
+#include "arrow/util/range.h"
 #include "arrow/util/ree_util.h"
+#include "arrow/util/span.h"
 
 namespace arrow {
 
@@ -917,6 +919,21 @@ Status MapTakeExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
   return TakeExec<ListSelectionImpl<MapType>>(ctx, batch, out);
 }
 
+void CloneBinaryViewCharacterBuffers(const ArraySpan& values, ArrayData* out_arr) {
+  // copy the character buffers into the output
+  util::span char_buffers(
+      reinterpret_cast<const std::shared_ptr<Buffer>*>(values.buffers[2].data),
+      values.buffers[2].size / sizeof(std::shared_ptr<Buffer>));
+
+  out_arr->buffers.resize(char_buffers.size() + 2);
+  auto out_char_buffers = util::span(out_arr->buffers).subspan(2);
+
+  for (auto&& [out_char_buffer, char_buffer] :
+       arrow::internal::Zip(out_char_buffers, char_buffers)) {
+    out_char_buffer = char_buffer;
+  }
+}
+
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_internal.h b/cpp/src/arrow/compute/kernels/vector_selection_internal.h
index bcffdd820db..63692f3a173 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_internal.h
+++ b/cpp/src/arrow/compute/kernels/vector_selection_internal.h
@@ -85,6 +85,8 @@ Status DenseUnionTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
 Status StructTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
 Status MapTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
 
+void CloneBinaryViewCharacterBuffers(const ArraySpan&, ArrayData*);
+
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_take_internal.cc b/cpp/src/arrow/compute/kernels/vector_selection_take_internal.cc
index ab80127731c..f5dc0e29b66 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_take_internal.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_take_internal.cc
@@ -48,8 +48,7 @@ using internal::BitBlockCounter;
 using internal::CheckIndexBounds;
 using internal::OptionalBitBlockCounter;
 
-namespace compute {
-namespace internal {
+namespace compute::internal {
 
 namespace {
 
@@ -386,7 +385,9 @@ struct PrimitiveTakeImpl {
             ++position;
           }
         } else {
-          memset(out + position, 0, sizeof(ValueCType) * block.length);
+          memset(static_cast<void*>(
+                     out + position),  // silence "StringHeader is non-trivial" warning
+                 0, sizeof(ValueCType) * block.length);
           position += block.length;
         }
       } else {
@@ -423,7 +424,9 @@ struct PrimitiveTakeImpl {
             ++position;
           }
         } else {
-          memset(out + position, 0, sizeof(ValueCType) * block.length);
+          memset(static_cast<void*>(
+                     out + position),  // silence "StringHeader is non-trivial" warning
+                 0, sizeof(ValueCType) * block.length);
           position += block.length;
         }
       }
@@ -595,6 +598,24 @@ Status PrimitiveTakeExec(KernelContext* ctx, const ExecSpan& batch, ExecResult*
   return Status::OK();
 }
 
+Status BinaryViewTakeExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+  const ArraySpan& values = batch[0].array;
+  const ArraySpan& indices = batch[1].array;
+
+  if (TakeState::Get(ctx).boundscheck) {
+    RETURN_NOT_OK(CheckIndexBounds(indices, values.length));
+  }
+
+  ArrayData* out_arr = out->array_data().get();
+  RETURN_NOT_OK(PreallocatePrimitiveArrayData(ctx, indices.length,
+                                              8 * sizeof(StringHeader),
+                                              /*allocate_validity=*/true, out_arr));
+  TakeIndexDispatch<PrimitiveTakeImpl, StringHeader>(values, indices, out_arr);
+
+  CloneBinaryViewCharacterBuffers(values, out_arr);
+  return Status::OK();
+}
+
 // ----------------------------------------------------------------------
 // Null take
 
@@ -834,6 +855,7 @@ void PopulateTakeKernels(std::vector<SelectionKernelData>* out) {
       {InputType(match::Primitive()), take_indices, PrimitiveTakeExec},
       {InputType(match::BinaryLike()), take_indices, VarBinaryTakeExec},
       {InputType(match::LargeBinaryLike()), take_indices, LargeVarBinaryTakeExec},
+      {InputType(match::BinaryViewLike()), take_indices, BinaryViewTakeExec},
       {InputType(Type::FIXED_SIZE_BINARY), take_indices, FSBTakeExec},
       {InputType(null()), take_indices, NullTakeExec},
       {InputType(Type::DECIMAL128), take_indices, FSBTakeExec},
@@ -849,6 +871,5 @@ void PopulateTakeKernels(std::vector<SelectionKernelData>* out) {
   };
 }
 
-}  // namespace internal
-}  // namespace compute
+}  // namespace compute::internal
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_test.cc b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
index 5b624911ff5..e7c9efadc11 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
@@ -593,7 +593,7 @@ TYPED_TEST(TestFilterKernelWithDecimal, FilterNumeric) {
                                 ArrayFromJSON(boolean(), "[]"), this->drop_));
 }
 
-TEST(TestFilterKernel, NoValidityBitmapButUnknownNullCount) {
+TEST_F(TestFilterKernel, NoValidityBitmapButUnknownNullCount) {
   auto values = ArrayFromJSON(int32(), "[1, 2, 3, 4]");
   auto filter = ArrayFromJSON(boolean(), "[true, true, false, true]");
 
@@ -644,6 +644,14 @@ TYPED_TEST(TestFilterKernelWithString, FilterString) {
   this->AssertFilter(R"(["a", "b", "c"])", "[null, 1, 0]", R"([null, "b"])");
 }
 
+TEST_F(TestFilterKernel, FilterStringView) {
+  for (auto type : {utf8_view(), binary_view()}) {
+    AssertFilter(type, R"(["a", "b", "c"])", "[0, 1, 0]", R"(["b"])");
+    AssertFilter(type, R"([null, "b", "c"])", "[0, 1, 0]", R"(["b"])");
+    AssertFilter(type, R"(["a", "b", "c"])", "[null, 1, 0]", R"([null, "b"])");
+  }
+}
+
 TYPED_TEST(TestFilterKernelWithString, FilterDictionary) {
   auto dict = R"(["a", "b", "c", "d", "e"])";
   this->AssertFilterDictionary(dict, "[3, 4, 2]", "[0, 1, 0]", "[4]");
@@ -1292,6 +1300,24 @@ TYPED_TEST(TestTakeKernelWithString, TakeString) {
                                      "[2, 5]", &arr));
 }
 
+TEST_F(TestTakeKernel, TakeStringView) {
+  for (auto type : {utf8_view(), binary_view()}) {
+    ARROW_SCOPED_TRACE(*type);
+    CheckTake(type, R"(["a", "b", "c"])", "[0, 1, 0]", R"(["a", "b", "a"])");
+    CheckTake(type, R"([null, "b", "c"])", "[0, 1, 0]", "[null, \"b\", null]");
+    CheckTake(type, R"(["a", "b", "c"])", "[null, 1, 0]", R"([null, "b", "a"])");
+
+    this->TestNoValidityBitmapButUnknownNullCount(type, R"(["a", "b", "c"])",
+                                                  "[0, 1, 0]");
+
+    std::shared_ptr<Array> arr;
+    ASSERT_RAISES(IndexError,
+                  TakeJSON(type, R"(["a", "b", "c"])", int8(), "[0, 9, 0]", &arr));
+    ASSERT_RAISES(IndexError, TakeJSON(type, R"(["a", "b", null, "ddd", "ee"])", int64(),
+                                       "[2, 5]", &arr));
+  }
+}
+
 TYPED_TEST(TestTakeKernelWithString, TakeDictionary) {
   auto dict = R"(["a", "b", "c", "d", "e"])";
   this->AssertTakeDictionary(dict, "[3, 4, 2]", "[0, 1, 0]", "[3, 4, 3]");
@@ -1897,6 +1923,7 @@ TEST(TestFilter, RandomBoolean) { FilterRandomTest<>::Test(boolean()); }
 TEST(TestFilter, RandomString) {
   FilterRandomTest<>::Test(utf8());
   FilterRandomTest<>::Test(large_utf8());
+  FilterRandomTest<>::Test(utf8_view());
 }
 
 TEST(TestFilter, RandomFixedSizeBinary) {
@@ -1911,6 +1938,7 @@ TEST(TestTake, RandomBoolean) { TakeRandomTest<BooleanType>::Test(boolean()); }
 TEST(TestTake, RandomString) {
   TakeRandomTest<StringType>::Test(utf8());
   TakeRandomTest<LargeStringType>::Test(large_utf8());
+  TakeRandomTest<StringViewType>::Test(utf8_view());
 }
 
 TEST(TestTake, RandomFixedSizeBinary) {
@@ -2046,12 +2074,21 @@ TYPED_TEST_SUITE(TestDropNullKernelWithString, BaseBinaryArrowTypes);
 
 TYPED_TEST(TestDropNullKernelWithString, DropNullString) {
   this->AssertDropNull(R"(["a", "b", "c"])", R"(["a", "b", "c"])");
-  this->AssertDropNull(R"([null, "b", "c"])", "[\"b\", \"c\"]");
+  this->AssertDropNull(R"([null, "b", "c"])", R"(["b", "c"])");
   this->AssertDropNull(R"(["a", "b", null])", R"(["a", "b"])");
 
   this->TestNoValidityBitmapButUnknownNullCount(this->value_type(), R"(["a", "b", "c"])");
 }
 
+TEST_F(TestDropNullKernel, DropNullStringView) {
+  for (auto type : {utf8_view(), binary_view()}) {
+    CheckDropNull(type, R"(["a", "b", "c"])", R"(["a", "b", "c"])");
+    CheckDropNull(type, R"([null, "b", "c"])", R"(["b", "c"])");
+    CheckDropNull(type, R"(["a", "b", null])", R"(["a", "b"])");
+    this->TestNoValidityBitmapButUnknownNullCount(type, R"(["a", "b", "c"])");
+  }
+}
+
 TYPED_TEST(TestDropNullKernelWithString, DropNullDictionary) {
   auto dict = R"(["a", "b", "c", "d", "e"])";
   this->AssertDropNullDictionary(dict, "[3, 4, 2]", "[3, 4, 2]");
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
index 0cefddff5a1..39cfa085912 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
@@ -25,8 +25,7 @@
 #include "arrow/util/benchmark_util.h"
 #include "arrow/util/logging.h"
 
-namespace arrow {
-namespace compute {
+namespace arrow::compute {
 
 constexpr auto kSeed = 0x0ff1ce;
 constexpr int32_t kDictionarySize = 24;  // a typical dictionary size
@@ -136,6 +135,21 @@ static void ArraySortFuncStringBenchmark(benchmark::State& state, const Runner&
   ArraySortFuncBenchmark(state, runner, values);
 }
 
+template <typename Runner>
+static void ArraySortFuncStringViewBenchmark(benchmark::State& state,
+                                             const Runner& runner, int32_t min_length,
+                                             int32_t max_length) {
+  RegressionArgs args(state);
+
+  const int64_t array_size =
+      GetStringArraySize(args.size, min_length, max_length, args.null_proportion);
+
+  auto rand = random::RandomArrayGenerator(kSeed);
+  auto values = rand.StringView(array_size, min_length, max_length, args.null_proportion);
+
+  ArraySortFuncBenchmark(state, runner, values);
+}
+
 template <typename Runner>
 static void ArraySortFuncStringDictBenchmark(benchmark::State& state,
                                              const Runner& runner, int32_t min_length,
@@ -271,6 +285,18 @@ static void ArraySortIndicesStringWideDict(benchmark::State& state) {
                                    dict_size);
 }
 
+static void ArraySortIndicesStringViewNarrow(benchmark::State& state) {
+  const auto min_length = 0;
+  const auto max_length = 16;
+  ArraySortFuncStringViewBenchmark(state, SortRunner(state), min_length, max_length);
+}
+
+static void ArraySortIndicesStringViewWide(benchmark::State& state) {
+  const auto min_length = 0;
+  const auto max_length = 64;
+  ArraySortFuncStringViewBenchmark(state, SortRunner(state), min_length, max_length);
+}
+
 static void ArrayRankStringNarrow(benchmark::State& state) {
   const auto min_length = 0;
   const auto max_length = 16;
@@ -458,6 +484,8 @@ BENCHMARK(ArraySortIndicesBool)->Apply(ArraySortIndicesSetArgs);
 BENCHMARK(ArraySortIndicesStringNarrow)->Apply(ArraySortIndicesSetArgs);
 BENCHMARK(ArraySortIndicesStringWide)->Apply(ArraySortIndicesSetArgs);
 BENCHMARK(ArraySortIndicesStringWideDict)->Apply(ArraySortIndicesSetArgs);
+BENCHMARK(ArraySortIndicesStringViewNarrow)->Apply(ArraySortIndicesSetArgs);
+BENCHMARK(ArraySortIndicesStringViewWide)->Apply(ArraySortIndicesSetArgs);
 
 BENCHMARK(ChunkedArraySortIndicesInt64Narrow)->Apply(ArraySortIndicesSetArgs);
 BENCHMARK(ChunkedArraySortIndicesInt64Wide)->Apply(ArraySortIndicesSetArgs);
@@ -534,5 +562,4 @@ BENCHMARK(ArrayRankStringWide)->Apply(ArrayRankSetArgs);
 BENCHMARK(ChunkedArrayRankInt64Narrow)->Apply(ArrayRankSetArgs);
 BENCHMARK(ChunkedArrayRankInt64Wide)->Apply(ArrayRankSetArgs);
 
-}  // namespace compute
-}  // namespace arrow
+}  // namespace arrow::compute
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
index 3429a5a8785..2bbee76172b 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -593,7 +593,7 @@ template <typename ArrowType>
 class TestArraySortIndicesForTemporal : public TestArraySortIndices<ArrowType> {};
 TYPED_TEST_SUITE(TestArraySortIndicesForTemporal, TemporalArrowTypes);
 
-using StringSortTestTypes = testing::Types<StringType, LargeStringType>;
+using StringSortTestTypes = testing::Types<StringType, LargeStringType, StringViewType>;
 
 template <typename ArrowType>
 class TestArraySortIndicesForStrings : public TestArraySortIndices<ArrowType> {};
diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc
index 5e214bdda4d..c595051dec9 100644
--- a/cpp/src/arrow/engine/substrait/expression_internal.cc
+++ b/cpp/src/arrow/engine/substrait/expression_internal.cc
@@ -710,6 +710,15 @@ struct ScalarToProtoImpl {
                       s);
   }
 
+  Status Visit(const StringViewScalar& s) {
+    return FromBuffer([](Lit* lit, std::string&& s) { lit->set_string(std::move(s)); },
+                      s);
+  }
+  Status Visit(const BinaryViewScalar& s) {
+    return FromBuffer([](Lit* lit, std::string&& s) { lit->set_binary(std::move(s)); },
+                      s);
+  }
+
   Status Visit(const FixedSizeBinaryScalar& s) {
     return FromBuffer(
         [](Lit* lit, std::string&& s) { lit->set_fixed_binary(std::move(s)); }, s);
diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc
index 03d1f999a14..89692df7bed 100644
--- a/cpp/src/arrow/engine/substrait/type_internal.cc
+++ b/cpp/src/arrow/engine/substrait/type_internal.cc
@@ -262,6 +262,13 @@ struct DataTypeToProtoImpl {
     return SetWith(&substrait::Type::set_allocated_binary);
   }
 
+  Status Visit(const StringViewType& t) {
+    return SetWith(&::substrait::Type::set_allocated_string);
+  }
+  Status Visit(const BinaryViewType& t) {
+    return SetWith(&::substrait::Type::set_allocated_binary);
+  }
+
   Status Visit(const FixedSizeBinaryType& t) {
     SetWithThen(&substrait::Type::set_allocated_fixed_binary)->set_length(t.byte_width());
     return Status::OK();
diff --git a/cpp/src/arrow/ipc/feather.cc b/cpp/src/arrow/ipc/feather.cc
index b6d3a3d7d8c..1ef076fac40 100644
--- a/cpp/src/arrow/ipc/feather.cc
+++ b/cpp/src/arrow/ipc/feather.cc
@@ -536,8 +536,8 @@ struct ArrayWriterV1 {
       is_nested_type<T>::value || is_null_type<T>::value || is_decimal_type<T>::value ||
           std::is_same<DictionaryType, T>::value || is_duration_type<T>::value ||
           is_interval_type<T>::value || is_fixed_size_binary_type<T>::value ||
-          std::is_same<Date64Type, T>::value || std::is_same<Time64Type, T>::value ||
-          std::is_same<ExtensionType, T>::value,
+          is_binary_view_like_type<T>::value || std::is_same<Date64Type, T>::value ||
+          std::is_same<Time64Type, T>::value || std::is_same<ExtensionType, T>::value,
       Status>::type
   Visit(const T& type) {
     return Status::NotImplemented(type.ToString());
diff --git a/cpp/src/arrow/ipc/feather_test.cc b/cpp/src/arrow/ipc/feather_test.cc
index e1d4282cb26..0b6ae4f6206 100644
--- a/cpp/src/arrow/ipc/feather_test.cc
+++ b/cpp/src/arrow/ipc/feather_test.cc
@@ -264,7 +264,8 @@ TEST_P(TestFeather, TimeTypes) {
 
 TEST_P(TestFeather, VLenPrimitiveRoundTrip) {
   std::shared_ptr<RecordBatch> batch;
-  ASSERT_OK(ipc::test::MakeStringTypesRecordBatch(&batch));
+  ASSERT_OK(ipc::test::MakeStringTypesRecordBatch(&batch, /*with_nulls=*/true,
+                                                  /*with_view_types=*/false));
   CheckRoundtrip(batch);
 }
 
@@ -306,7 +307,8 @@ TEST_P(TestFeather, SliceFloatRoundTrip) {
 
 TEST_P(TestFeather, SliceStringsRoundTrip) {
   std::shared_ptr<RecordBatch> batch;
-  ASSERT_OK(ipc::test::MakeStringTypesRecordBatch(&batch, /*with_nulls=*/true));
+  ASSERT_OK(ipc::test::MakeStringTypesRecordBatch(&batch, /*with_nulls=*/true,
+                                                  /*with_view_types=*/false));
   CheckSlices(batch);
 }
 
diff --git a/cpp/src/arrow/ipc/json_simple.cc b/cpp/src/arrow/ipc/json_simple.cc
index eea0c973028..4d2d803f3f6 100644
--- a/cpp/src/arrow/ipc/json_simple.cc
+++ b/cpp/src/arrow/ipc/json_simple.cc
@@ -847,6 +847,8 @@ Status GetDictConverter(const std::shared_ptr<DataType>& type,
     PARAM_CONVERTER_CASE(Type::BINARY, StringConverter, BinaryType)
     PARAM_CONVERTER_CASE(Type::LARGE_STRING, StringConverter, LargeStringType)
     PARAM_CONVERTER_CASE(Type::LARGE_BINARY, StringConverter, LargeBinaryType)
+    PARAM_CONVERTER_CASE(Type::STRING_VIEW, StringConverter, StringViewType)
+    PARAM_CONVERTER_CASE(Type::BINARY_VIEW, StringConverter, BinaryViewType)
     SIMPLE_CONVERTER_CASE(Type::FIXED_SIZE_BINARY, FixedSizeBinaryConverter,
                           FixedSizeBinaryType)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL128, Decimal128Converter, Decimal128Type)
@@ -905,6 +907,8 @@ Status GetConverter(const std::shared_ptr<DataType>& type,
     SIMPLE_CONVERTER_CASE(Type::BINARY, StringConverter<BinaryType>)
     SIMPLE_CONVERTER_CASE(Type::LARGE_STRING, StringConverter<LargeStringType>)
     SIMPLE_CONVERTER_CASE(Type::LARGE_BINARY, StringConverter<LargeBinaryType>)
+    SIMPLE_CONVERTER_CASE(Type::STRING_VIEW, StringConverter<StringViewType>)
+    SIMPLE_CONVERTER_CASE(Type::BINARY_VIEW, StringConverter<BinaryViewType>)
     SIMPLE_CONVERTER_CASE(Type::FIXED_SIZE_BINARY, FixedSizeBinaryConverter<>)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL128, Decimal128Converter<>)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL256, Decimal256Converter<>)
diff --git a/cpp/src/arrow/ipc/json_simple_test.cc b/cpp/src/arrow/ipc/json_simple_test.cc
index 6eee5955242..11d296f24f5 100644
--- a/cpp/src/arrow/ipc/json_simple_test.cc
+++ b/cpp/src/arrow/ipc/json_simple_test.cc
@@ -327,6 +327,8 @@ INSTANTIATE_TYPED_TEST_SUITE_P(TestString, TestStrings, StringType);
 INSTANTIATE_TYPED_TEST_SUITE_P(TestBinary, TestStrings, BinaryType);
 INSTANTIATE_TYPED_TEST_SUITE_P(TestLargeString, TestStrings, LargeStringType);
 INSTANTIATE_TYPED_TEST_SUITE_P(TestLargeBinary, TestStrings, LargeBinaryType);
+INSTANTIATE_TYPED_TEST_SUITE_P(TestStringView, TestStrings, StringViewType);
+INSTANTIATE_TYPED_TEST_SUITE_P(TestBinaryView, TestStrings, BinaryViewType);
 
 TEST(TestNull, Basics) {
   std::shared_ptr<DataType> type = null();
diff --git a/cpp/src/arrow/ipc/metadata_internal.cc b/cpp/src/arrow/ipc/metadata_internal.cc
index 1394516ecd5..23accc2390f 100644
--- a/cpp/src/arrow/ipc/metadata_internal.cc
+++ b/cpp/src/arrow/ipc/metadata_internal.cc
@@ -258,6 +258,9 @@ Status ConcreteTypeFromFlatbuffer(flatbuf::Type type, const void* type_data,
     case flatbuf::Type::LargeBinary:
       *out = large_binary();
       return Status::OK();
+    case flatbuf::Type::BinaryView:
+      *out = binary_view();
+      return Status::OK();
     case flatbuf::Type::FixedSizeBinary: {
       auto fw_binary = static_cast<const flatbuf::FixedSizeBinary*>(type_data);
       return FixedSizeBinaryType::Make(fw_binary->byteWidth()).Value(out);
@@ -268,6 +271,9 @@ Status ConcreteTypeFromFlatbuffer(flatbuf::Type type, const void* type_data,
     case flatbuf::Type::LargeUtf8:
       *out = large_utf8();
       return Status::OK();
+    case flatbuf::Type::Utf8View:
+      *out = utf8_view();
+      return Status::OK();
     case flatbuf::Type::Bool:
       *out = boolean();
       return Status::OK();
@@ -534,6 +540,26 @@ class FieldToFlatbufferVisitor {
     return Status::OK();
   }
 
+  static Status CheckForRawPointers(const BinaryViewType& type) {
+    if (type.has_raw_pointers()) {
+      return Status::NotImplemented(
+          type.ToString(), " cannot be serialized; convert to index/offset format first");
+    }
+    return Status::OK();
+  }
+
+  Status Visit(const BinaryViewType& type) {
+    fb_type_ = flatbuf::Type::BinaryView;
+    type_offset_ = flatbuf::CreateBinaryView(fbb_).Union();
+    return CheckForRawPointers(type);
+  }
+
+  Status Visit(const StringViewType& type) {
+    fb_type_ = flatbuf::Type::Utf8View;
+    type_offset_ = flatbuf::CreateUtf8View(fbb_).Union();
+    return CheckForRawPointers(type);
+  }
+
   Status Visit(const LargeBinaryType& type) {
     fb_type_ = flatbuf::Type::LargeBinary;
     type_offset_ = flatbuf::CreateLargeBinary(fbb_).Union();
@@ -820,7 +846,7 @@ Status FieldFromFlatbuffer(const flatbuf::Field* field, FieldPosition field_pos,
     dictionary_id = encoding->id();
   }
 
-  // 4. Is it an extension type?
+  // 4. Is it an extension or view type?
   if (metadata != nullptr) {
     // Look for extension metadata in custom_metadata field
     int name_index = metadata->FindKey(kExtensionTypeKeyName);
@@ -967,6 +993,7 @@ static Status GetBodyCompression(FBB& fbb, const IpcWriteOptions& options,
 static Status MakeRecordBatch(FBB& fbb, int64_t length, int64_t body_length,
                               const std::vector<FieldMetadata>& nodes,
                               const std::vector<BufferMetadata>& buffers,
+                              const std::vector<int64_t>& variadic_counts,
                               const IpcWriteOptions& options, RecordBatchOffset* offset) {
   FieldNodeVector fb_nodes;
   RETURN_NOT_OK(WriteFieldNodes(fbb, nodes, &fb_nodes));
@@ -977,7 +1004,10 @@ static Status MakeRecordBatch(FBB& fbb, int64_t length, int64_t body_length,
   BodyCompressionOffset fb_compression;
   RETURN_NOT_OK(GetBodyCompression(fbb, options, &fb_compression));
 
-  *offset = flatbuf::CreateRecordBatch(fbb, length, fb_nodes, fb_buffers, fb_compression);
+  auto fb_variadic_counts = fbb.CreateVector(variadic_counts);
+
+  *offset = flatbuf::CreateRecordBatch(fbb, length, fb_nodes, fb_buffers, fb_compression,
+                                       fb_variadic_counts);
   return Status::OK();
 }
 
@@ -1224,11 +1254,12 @@ Status WriteRecordBatchMessage(
     int64_t length, int64_t body_length,
     const std::shared_ptr<const KeyValueMetadata>& custom_metadata,
     const std::vector<FieldMetadata>& nodes, const std::vector<BufferMetadata>& buffers,
-    const IpcWriteOptions& options, std::shared_ptr<Buffer>* out) {
+    const std::vector<int64_t>& variadic_counts, const IpcWriteOptions& options,
+    std::shared_ptr<Buffer>* out) {
   FBB fbb;
   RecordBatchOffset record_batch;
-  RETURN_NOT_OK(
-      MakeRecordBatch(fbb, length, body_length, nodes, buffers, options, &record_batch));
+  RETURN_NOT_OK(MakeRecordBatch(fbb, length, body_length, nodes, buffers, variadic_counts,
+                                options, &record_batch));
   return WriteFBMessage(fbb, flatbuf::MessageHeader::RecordBatch, record_batch.Union(),
                         body_length, options.metadata_version, custom_metadata,
                         options.memory_pool)
@@ -1285,11 +1316,12 @@ Status WriteDictionaryMessage(
     int64_t id, bool is_delta, int64_t length, int64_t body_length,
     const std::shared_ptr<const KeyValueMetadata>& custom_metadata,
     const std::vector<FieldMetadata>& nodes, const std::vector<BufferMetadata>& buffers,
-    const IpcWriteOptions& options, std::shared_ptr<Buffer>* out) {
+    const std::vector<int64_t>& variadic_counts, const IpcWriteOptions& options,
+    std::shared_ptr<Buffer>* out) {
   FBB fbb;
   RecordBatchOffset record_batch;
-  RETURN_NOT_OK(
-      MakeRecordBatch(fbb, length, body_length, nodes, buffers, options, &record_batch));
+  RETURN_NOT_OK(MakeRecordBatch(fbb, length, body_length, nodes, buffers, variadic_counts,
+                                options, &record_batch));
   auto dictionary_batch =
       flatbuf::CreateDictionaryBatch(fbb, id, record_batch, is_delta).Union();
   return WriteFBMessage(fbb, flatbuf::MessageHeader::DictionaryBatch, dictionary_batch,
diff --git a/cpp/src/arrow/ipc/metadata_internal.h b/cpp/src/arrow/ipc/metadata_internal.h
index abbed5b2dac..631a336f75a 100644
--- a/cpp/src/arrow/ipc/metadata_internal.h
+++ b/cpp/src/arrow/ipc/metadata_internal.h
@@ -201,7 +201,8 @@ Status WriteRecordBatchMessage(
     const int64_t length, const int64_t body_length,
     const std::shared_ptr<const KeyValueMetadata>& custom_metadata,
     const std::vector<FieldMetadata>& nodes, const std::vector<BufferMetadata>& buffers,
-    const IpcWriteOptions& options, std::shared_ptr<Buffer>* out);
+    const std::vector<int64_t>& variadic_counts, const IpcWriteOptions& options,
+    std::shared_ptr<Buffer>* out);
 
 ARROW_EXPORT
 Result<std::shared_ptr<Buffer>> WriteTensorMessage(const Tensor& tensor,
@@ -225,7 +226,8 @@ Status WriteDictionaryMessage(
     const int64_t body_length,
     const std::shared_ptr<const KeyValueMetadata>& custom_metadata,
     const std::vector<FieldMetadata>& nodes, const std::vector<BufferMetadata>& buffers,
-    const IpcWriteOptions& options, std::shared_ptr<Buffer>* out);
+    const std::vector<int64_t>& variadic_counts, const IpcWriteOptions& options,
+    std::shared_ptr<Buffer>* out);
 
 static inline Result<std::shared_ptr<Buffer>> WriteFlatbufferBuilder(
     flatbuffers::FlatBufferBuilder& fbb,  // NOLINT non-const reference
diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc
index 7de81eff7a7..9fb37d4b9f3 100644
--- a/cpp/src/arrow/ipc/read_write_test.cc
+++ b/cpp/src/arrow/ipc/read_write_test.cc
@@ -159,7 +159,7 @@ TEST_P(TestMessage, SerializeCustomMetadata) {
     ASSERT_OK(internal::WriteRecordBatchMessage(
         /*length=*/0, /*body_length=*/0, metadata,
         /*nodes=*/{},
-        /*buffers=*/{}, options_, &serialized));
+        /*buffers=*/{}, /*variadic_counts=*/{}, options_, &serialized));
     ASSERT_OK_AND_ASSIGN(std::unique_ptr<Message> message,
                          Message::Open(serialized, /*body=*/nullptr));
 
@@ -240,23 +240,33 @@ class TestSchemaMetadata : public ::testing::Test {
   }
 };
 
-const std::shared_ptr<DataType> INT32 = std::make_shared<Int32Type>();
-
 TEST_F(TestSchemaMetadata, PrimitiveFields) {
-  auto f0 = field("f0", std::make_shared<Int8Type>());
-  auto f1 = field("f1", std::make_shared<Int16Type>(), false);
-  auto f2 = field("f2", std::make_shared<Int32Type>());
-  auto f3 = field("f3", std::make_shared<Int64Type>());
-  auto f4 = field("f4", std::make_shared<UInt8Type>());
-  auto f5 = field("f5", std::make_shared<UInt16Type>());
-  auto f6 = field("f6", std::make_shared<UInt32Type>());
-  auto f7 = field("f7", std::make_shared<UInt64Type>());
-  auto f8 = field("f8", std::make_shared<FloatType>());
-  auto f9 = field("f9", std::make_shared<DoubleType>(), false);
-  auto f10 = field("f10", std::make_shared<BooleanType>());
-
-  Schema schema({f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10});
-  CheckSchemaRoundtrip(schema);
+  CheckSchemaRoundtrip(Schema({
+      field("f0", int8()),
+      field("f1", int16(), false),
+      field("f2", int32()),
+      field("f3", int64()),
+      field("f4", uint8()),
+      field("f5", uint16()),
+      field("f6", uint32()),
+      field("f7", uint64()),
+      field("f8", float32()),
+      field("f9", float64(), false),
+      field("f10", boolean()),
+  }));
+}
+
+TEST_F(TestSchemaMetadata, BinaryFields) {
+  CheckSchemaRoundtrip(Schema({
+      field("f0", utf8()),
+      field("f1", binary()),
+      field("f2", large_utf8()),
+      field("f3", large_binary()),
+      field("f4", utf8_view()),
+      field("f5", binary_view()),
+      field("f6", fixed_size_binary(3)),
+      field("f7", fixed_size_binary(33)),
+  }));
 }
 
 TEST_F(TestSchemaMetadata, PrimitiveFieldsWithKeyValueMetadata) {
@@ -269,15 +279,14 @@ TEST_F(TestSchemaMetadata, PrimitiveFieldsWithKeyValueMetadata) {
 }
 
 TEST_F(TestSchemaMetadata, NestedFields) {
-  auto type = list(int32());
-  auto f0 = field("f0", type);
-
-  std::shared_ptr<StructType> type2(
-      new StructType({field("k1", INT32), field("k2", INT32), field("k3", INT32)}));
-  auto f1 = field("f1", type2);
-
-  Schema schema({f0, f1});
-  CheckSchemaRoundtrip(schema);
+  CheckSchemaRoundtrip(Schema({
+      field("f0", list(int32())),
+      field("f1", struct_({
+                      field("k1", int32()),
+                      field("k2", int32()),
+                      field("k3", int32()),
+                  })),
+  }));
 }
 
 // Verify that nullable=false is well-preserved for child fields of map type.
@@ -305,19 +314,15 @@ TEST_F(TestSchemaMetadata, NestedFieldsWithKeyValueMetadata) {
 
 TEST_F(TestSchemaMetadata, DictionaryFields) {
   {
-    auto dict_type = dictionary(int8(), int32(), true /* ordered */);
-    auto f0 = field("f0", dict_type);
-    auto f1 = field("f1", list(dict_type));
-
-    Schema schema({f0, f1});
-    CheckSchemaRoundtrip(schema);
+    auto dict_type = dictionary(int8(), int32(), /*ordered=*/true);
+    CheckSchemaRoundtrip(Schema({
+        field("f0", dict_type),
+        field("f1", list(dict_type)),
+    }));
   }
   {
     auto dict_type = dictionary(int8(), list(int32()));
-    auto f0 = field("f0", dict_type);
-
-    Schema schema({f0});
-    CheckSchemaRoundtrip(schema);
+    CheckSchemaRoundtrip(Schema({field("f0", dict_type)}));
   }
 }
 
@@ -325,9 +330,7 @@ TEST_F(TestSchemaMetadata, NestedDictionaryFields) {
   {
     auto inner_dict_type = dictionary(int8(), int32(), /*ordered=*/true);
     auto dict_type = dictionary(int16(), list(inner_dict_type));
-
-    Schema schema({field("f0", dict_type)});
-    CheckSchemaRoundtrip(schema);
+    CheckSchemaRoundtrip(Schema({field("f0", dict_type)}));
   }
   {
     auto dict_type1 = dictionary(int8(), utf8(), /*ordered=*/true);
@@ -2870,21 +2873,21 @@ void GetReadRecordBatchReadRanges(
   // 1) read magic and footer length IO
   // 2) read footer IO
   // 3) read record batch metadata IO
-  ASSERT_EQ(read_ranges.size(), 3 + expected_body_read_lengths.size());
+  EXPECT_EQ(read_ranges.size(), 3 + expected_body_read_lengths.size());
   const int32_t magic_size = static_cast<int>(strlen(ipc::internal::kArrowMagicBytes));
   // read magic and footer length IO
   auto file_end_size = magic_size + sizeof(int32_t);
   auto footer_length_offset = buffer->size() - file_end_size;
   auto footer_length = bit_util::FromLittleEndian(
       util::SafeLoadAs<int32_t>(buffer->data() + footer_length_offset));
-  ASSERT_EQ(read_ranges[0].length, file_end_size);
+  EXPECT_EQ(read_ranges[0].length, file_end_size);
   // read footer IO
-  ASSERT_EQ(read_ranges[1].length, footer_length);
+  EXPECT_EQ(read_ranges[1].length, footer_length);
   // read record batch metadata.  The exact size is tricky to determine but it doesn't
   // matter for this test and it should be smaller than the footer.
-  ASSERT_LT(read_ranges[2].length, footer_length);
+  EXPECT_LE(read_ranges[2].length, footer_length);
   for (uint32_t i = 0; i < expected_body_read_lengths.size(); i++) {
-    ASSERT_EQ(read_ranges[3 + i].length, expected_body_read_lengths[i]);
+    EXPECT_EQ(read_ranges[3 + i].length, expected_body_read_lengths[i]);
   }
 }
 
diff --git a/cpp/src/arrow/ipc/reader.cc b/cpp/src/arrow/ipc/reader.cc
index 694cc732253..efe81ce573e 100644
--- a/cpp/src/arrow/ipc/reader.cc
+++ b/cpp/src/arrow/ipc/reader.cc
@@ -58,6 +58,7 @@
 #include "arrow/util/thread_pool.h"
 #include "arrow/util/ubsan.h"
 #include "arrow/util/vector.h"
+#include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
 
 #include "generated/File_generated.h"  // IWYU pragma: export
@@ -243,6 +244,15 @@ class ArrayLoader {
     }
   }
 
+  Result<size_t> GetVariadicCount(int i) {
+    auto* variadic_counts = metadata_->variadicCounts();
+    CHECK_FLATBUFFERS_NOT_NULL(variadic_counts, "RecordBatch.variadicCounts");
+    if (i >= static_cast<int>(variadic_counts->size())) {
+      return Status::IOError("variadic_count_index out of range.");
+    }
+    return static_cast<size_t>(variadic_counts->Get(i));
+  }
+
   Status GetFieldMetadata(int field_index, ArrayData* out) {
     auto nodes = metadata_->nodes();
     CHECK_FLATBUFFERS_NOT_NULL(nodes, "Table.nodes");
@@ -289,7 +299,6 @@ class ArrayLoader {
     return Status::OK();
   }
 
-  template <typename TYPE>
   Status LoadBinary(Type::type type_id) {
     out_->buffers.resize(3);
 
@@ -345,7 +354,22 @@ class ArrayLoader {
 
   template <typename T>
   enable_if_base_binary<T, Status> Visit(const T& type) {
-    return LoadBinary<T>(type.id());
+    return LoadBinary(type.id());
+  }
+
+  Status Visit(const BinaryViewType& type) {
+    out_->buffers.resize(2);
+
+    RETURN_NOT_OK(LoadCommon(type.id()));
+    RETURN_NOT_OK(GetBuffer(buffer_index_++, &out_->buffers[1]));
+
+    ARROW_ASSIGN_OR_RAISE(auto character_buffer_count,
+                          GetVariadicCount(variadic_count_index_++));
+    out_->buffers.resize(character_buffer_count + 2);
+    for (size_t i = 0; i < character_buffer_count; ++i) {
+      RETURN_NOT_OK(GetBuffer(buffer_index_++, &out_->buffers[i + 2]));
+    }
+    return Status::OK();
   }
 
   Status Visit(const FixedSizeBinaryType& type) {
@@ -440,6 +464,7 @@ class ArrayLoader {
   int buffer_index_ = 0;
   int field_index_ = 0;
   bool skip_io_ = false;
+  int variadic_count_index_ = 0;
 
   BatchDataReadRequest read_request_;
   const Field* field_ = nullptr;
@@ -570,9 +595,9 @@ Result<std::shared_ptr<RecordBatch>> LoadRecordBatchSubset(
 
   // swap endian in a set of ArrayData if necessary (swap_endian == true)
   if (context.swap_endian) {
-    for (int i = 0; i < static_cast<int>(filtered_columns.size()); ++i) {
-      ARROW_ASSIGN_OR_RAISE(filtered_columns[i],
-                            arrow::internal::SwapEndianArrayData(filtered_columns[i]));
+    for (auto& filtered_column : filtered_columns) {
+      ARROW_ASSIGN_OR_RAISE(filtered_column,
+                            arrow::internal::SwapEndianArrayData(filtered_column));
     }
   }
   return RecordBatch::Make(std::move(filtered_schema), metadata->length(),
diff --git a/cpp/src/arrow/ipc/test_common.cc b/cpp/src/arrow/ipc/test_common.cc
index 53721c0b20f..6faaf96b332 100644
--- a/cpp/src/arrow/ipc/test_common.cc
+++ b/cpp/src/arrow/ipc/test_common.cc
@@ -351,39 +351,32 @@ static Status MakeBinaryArrayWithUniqueValues(int64_t length, bool include_nulls
   return builder.Finish(out);
 }
 
-Status MakeStringTypesRecordBatch(std::shared_ptr<RecordBatch>* out, bool with_nulls) {
+Status MakeStringTypesRecordBatch(std::shared_ptr<RecordBatch>* out, bool with_nulls,
+                                  bool with_view_types) {
   const int64_t length = 500;
-  auto f0 = field("strings", utf8());
-  auto f1 = field("binaries", binary());
-  auto f2 = field("large_strings", large_utf8());
-  auto f3 = field("large_binaries", large_binary());
-  auto schema = ::arrow::schema({f0, f1, f2, f3});
-
-  std::shared_ptr<Array> a0, a1, a2, a3;
-  MemoryPool* pool = default_memory_pool();
 
-  // Quirk with RETURN_NOT_OK macro and templated functions
-  {
-    auto s =
-        MakeBinaryArrayWithUniqueValues<StringBuilder>(length, with_nulls, pool, &a0);
-    RETURN_NOT_OK(s);
+  ArrayVector arrays;
+  FieldVector fields;
+
+  auto AppendColumn = [&](auto& MakeArray) {
+    arrays.emplace_back();
+    RETURN_NOT_OK(MakeArray(length, with_nulls, default_memory_pool(), &arrays.back()));
+
+    const auto& type = arrays.back()->type();
+    fields.push_back(field(type->ToString(), type));
+    return Status::OK();
+  };
+
+  RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<StringBuilder>));
+  RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<BinaryBuilder>));
+  RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<LargeStringBuilder>));
+  RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<LargeBinaryBuilder>));
+  if (with_view_types) {
+    RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<StringViewBuilder>));
+    RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<BinaryViewBuilder>));
   }
-  {
-    auto s =
-        MakeBinaryArrayWithUniqueValues<BinaryBuilder>(length, with_nulls, pool, &a1);
-    RETURN_NOT_OK(s);
-  }
-  {
-    auto s = MakeBinaryArrayWithUniqueValues<LargeStringBuilder>(length, with_nulls, pool,
-                                                                 &a2);
-    RETURN_NOT_OK(s);
-  }
-  {
-    auto s = MakeBinaryArrayWithUniqueValues<LargeBinaryBuilder>(length, with_nulls, pool,
-                                                                 &a3);
-    RETURN_NOT_OK(s);
-  }
-  *out = RecordBatch::Make(schema, length, {a0, a1, a2, a3});
+
+  *out = RecordBatch::Make(schema(std::move(fields)), length, std::move(arrays));
   return Status::OK();
 }
 
diff --git a/cpp/src/arrow/ipc/test_common.h b/cpp/src/arrow/ipc/test_common.h
index 5e0c65556c6..fc0c8ddbea3 100644
--- a/cpp/src/arrow/ipc/test_common.h
+++ b/cpp/src/arrow/ipc/test_common.h
@@ -96,7 +96,7 @@ Status MakeRandomStringArray(int64_t length, bool include_nulls, MemoryPool* poo
 
 ARROW_TESTING_EXPORT
 Status MakeStringTypesRecordBatch(std::shared_ptr<RecordBatch>* out,
-                                  bool with_nulls = true);
+                                  bool with_nulls = true, bool with_view_types = true);
 
 ARROW_TESTING_EXPORT
 Status MakeStringTypesRecordBatchWithNulls(std::shared_ptr<RecordBatch>* out);
diff --git a/cpp/src/arrow/ipc/writer.cc b/cpp/src/arrow/ipc/writer.cc
index f0f0e96ee46..70d66ebfaaf 100644
--- a/cpp/src/arrow/ipc/writer.cc
+++ b/cpp/src/arrow/ipc/writer.cc
@@ -52,10 +52,12 @@
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/compression.h"
 #include "arrow/util/endian.h"
+#include "arrow/util/int_util_overflow.h"
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/parallel.h"
 #include "arrow/visit_array_inline.h"
+#include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
 
 namespace arrow {
@@ -174,7 +176,8 @@ class RecordBatchSerializer {
   // Override this for writing dictionary metadata
   virtual Status SerializeMetadata(int64_t num_rows) {
     return WriteRecordBatchMessage(num_rows, out_->body_length, custom_metadata_,
-                                   field_nodes_, buffer_meta_, options_, &out_->metadata);
+                                   field_nodes_, buffer_meta_, variadic_counts_, options_,
+                                   &out_->metadata);
   }
 
   bool ShouldCompress(int64_t uncompressed_size, int64_t compressed_size) const {
@@ -291,6 +294,8 @@ class RecordBatchSerializer {
       offset += size + padding;
     }
 
+    variadic_counts_ = out_->variadic_counts;
+
     out_->body_length = offset - buffer_start_offset_;
     DCHECK(bit_util::IsMultipleOf8(out_->body_length));
 
@@ -398,6 +403,18 @@ class RecordBatchSerializer {
     return Status::OK();
   }
 
+  Status Visit(const BinaryViewArray& array) {
+    auto headers = SliceBuffer(array.values(), array.offset() * sizeof(StringHeader),
+                               array.length() * sizeof(StringHeader));
+    out_->body_buffers.emplace_back(std::move(headers));
+
+    out_->variadic_counts.emplace_back(array.data()->buffers.size() - 2);
+    for (size_t i = 2; i < array.data()->buffers.size(); ++i) {
+      out_->body_buffers.emplace_back(array.data()->buffers[i]);
+    }
+    return Status::OK();
+  }
+
   template <typename T>
   enable_if_base_list<typename T::TypeClass, Status> Visit(const T& array) {
     using offset_type = typename T::offset_type;
@@ -585,6 +602,7 @@ class RecordBatchSerializer {
 
   std::vector<internal::FieldMetadata> field_nodes_;
   std::vector<internal::BufferMetadata> buffer_meta_;
+  std::vector<int64_t> variadic_counts_;
 
   const IpcWriteOptions& options_;
   int64_t max_recursion_depth_;
@@ -601,8 +619,8 @@ class DictionarySerializer : public RecordBatchSerializer {
 
   Status SerializeMetadata(int64_t num_rows) override {
     return WriteDictionaryMessage(dictionary_id_, is_delta_, num_rows, out_->body_length,
-                                  custom_metadata_, field_nodes_, buffer_meta_, options_,
-                                  &out_->metadata);
+                                  custom_metadata_, field_nodes_, buffer_meta_,
+                                  variadic_counts_, options_, &out_->metadata);
   }
 
   Status Assemble(const std::shared_ptr<Array>& dictionary) {
diff --git a/cpp/src/arrow/ipc/writer.h b/cpp/src/arrow/ipc/writer.h
index 9e18a213ba3..0b62c011d88 100644
--- a/cpp/src/arrow/ipc/writer.h
+++ b/cpp/src/arrow/ipc/writer.h
@@ -57,6 +57,7 @@ struct IpcPayload {
   MessageType type = MessageType::NONE;
   std::shared_ptr<Buffer> metadata;
   std::vector<std::shared_ptr<Buffer>> body_buffers;
+  std::vector<int64_t> variadic_counts;
   int64_t body_length = 0;      // serialized body length (padded, maybe compressed)
   int64_t raw_body_length = 0;  // initial uncompressed body length
 };
diff --git a/cpp/src/arrow/json/converter.cc b/cpp/src/arrow/json/converter.cc
index 04ebe4714ce..c393b77acf3 100644
--- a/cpp/src/arrow/json/converter.cc
+++ b/cpp/src/arrow/json/converter.cc
@@ -304,6 +304,8 @@ Status MakeConverter(const std::shared_ptr<DataType>& out_type, MemoryPool* pool
     CONVERTER_CASE(Type::STRING, BinaryConverter<StringType>);
     CONVERTER_CASE(Type::LARGE_BINARY, BinaryConverter<LargeBinaryType>);
     CONVERTER_CASE(Type::LARGE_STRING, BinaryConverter<LargeStringType>);
+    CONVERTER_CASE(Type::BINARY_VIEW, BinaryConverter<BinaryViewType>);
+    CONVERTER_CASE(Type::STRING_VIEW, BinaryConverter<StringViewType>);
     CONVERTER_CASE(Type::DECIMAL128, DecimalConverter<Decimal128Type>);
     CONVERTER_CASE(Type::DECIMAL256, DecimalConverter<Decimal256Type>);
     default:
diff --git a/cpp/src/arrow/json/test_common.h b/cpp/src/arrow/json/test_common.h
index 0f7b3466fdb..f7ab6fd1027 100644
--- a/cpp/src/arrow/json/test_common.h
+++ b/cpp/src/arrow/json/test_common.h
@@ -110,8 +110,7 @@ struct GenerateImpl {
     return OK(writer.Double(val));
   }
 
-  template <typename T>
-  enable_if_base_binary<T, Status> Visit(const T&) {
+  Status GenerateAscii(const DataType&) {
     auto size = std::poisson_distribution<>{4}(e);
     std::uniform_int_distribution<uint16_t> gen_char(32, 126);  // FIXME generate UTF8
     std::string s(size, '\0');
@@ -119,6 +118,13 @@ struct GenerateImpl {
     return OK(writer.String(s.c_str()));
   }
 
+  template <typename T>
+  enable_if_base_binary<T, Status> Visit(const T& t) {
+    return GenerateAscii(t);
+  }
+
+  Status Visit(const BinaryViewType& t) { return GenerateAscii(t); }
+
   template <typename T>
   enable_if_list_like<T, Status> Visit(const T& t) {
     auto size = std::poisson_distribution<>{4}(e);
diff --git a/cpp/src/arrow/scalar.cc b/cpp/src/arrow/scalar.cc
index 0537ddafe29..c20f7396990 100644
--- a/cpp/src/arrow/scalar.cc
+++ b/cpp/src/arrow/scalar.cc
@@ -263,6 +263,12 @@ struct ScalarValidateImpl {
 
   Status Visit(const StringScalar& s) { return ValidateStringScalar(s); }
 
+  Status Visit(const BinaryViewScalar& s) { return ValidateBinaryScalar(s); }
+
+  Status Visit(const StringViewScalar& s) { return ValidateStringScalar(s); }
+
+  Status Visit(const LargeBinaryScalar& s) { return ValidateBinaryScalar(s); }
+
   Status Visit(const LargeStringScalar& s) { return ValidateStringScalar(s); }
 
   template <typename ScalarType>
@@ -548,17 +554,8 @@ Status Scalar::ValidateFull() const {
   return ScalarValidateImpl(/*full_validation=*/true).Validate(*this);
 }
 
-BinaryScalar::BinaryScalar(std::string s)
-    : BinaryScalar(Buffer::FromString(std::move(s))) {}
-
-StringScalar::StringScalar(std::string s)
-    : StringScalar(Buffer::FromString(std::move(s))) {}
-
-LargeBinaryScalar::LargeBinaryScalar(std::string s)
-    : LargeBinaryScalar(Buffer::FromString(std::move(s))) {}
-
-LargeStringScalar::LargeStringScalar(std::string s)
-    : LargeStringScalar(Buffer::FromString(std::move(s))) {}
+BaseBinaryScalar::BaseBinaryScalar(std::string s, std::shared_ptr<DataType> type)
+    : BaseBinaryScalar(Buffer::FromString(std::move(s)), std::move(type)) {}
 
 FixedSizeBinaryScalar::FixedSizeBinaryScalar(std::shared_ptr<Buffer> value,
                                              std::shared_ptr<DataType> type,
diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h
index d23b33e28f7..97a6b4787d4 100644
--- a/cpp/src/arrow/scalar.h
+++ b/cpp/src/arrow/scalar.h
@@ -37,6 +37,7 @@
 #include "arrow/type_traits.h"
 #include "arrow/util/compare.h"
 #include "arrow/util/decimal.h"
+#include "arrow/util/string_header.h"
 #include "arrow/util/visibility.h"
 #include "arrow/visit_type_inline.h"
 
@@ -254,22 +255,20 @@ struct ARROW_EXPORT BaseBinaryScalar : public internal::PrimitiveScalarBase {
     return value ? std::string_view(*value) : std::string_view();
   }
 
- protected:
   BaseBinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)
       : internal::PrimitiveScalarBase{std::move(type), true}, value(std::move(value)) {}
+
+  BaseBinaryScalar(std::string s, std::shared_ptr<DataType> type);
 };
 
 struct ARROW_EXPORT BinaryScalar : public BaseBinaryScalar {
   using BaseBinaryScalar::BaseBinaryScalar;
   using TypeClass = BinaryType;
 
-  BinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)
-      : BaseBinaryScalar(std::move(value), std::move(type)) {}
-
   explicit BinaryScalar(std::shared_ptr<Buffer> value)
       : BinaryScalar(std::move(value), binary()) {}
 
-  explicit BinaryScalar(std::string s);
+  explicit BinaryScalar(std::string s) : BaseBinaryScalar(std::move(s), binary()) {}
 
   BinaryScalar() : BinaryScalar(binary()) {}
 };
@@ -281,11 +280,39 @@ struct ARROW_EXPORT StringScalar : public BinaryScalar {
   explicit StringScalar(std::shared_ptr<Buffer> value)
       : StringScalar(std::move(value), utf8()) {}
 
-  explicit StringScalar(std::string s);
+  explicit StringScalar(std::string s) : BinaryScalar(std::move(s), utf8()) {}
 
   StringScalar() : StringScalar(utf8()) {}
 };
 
+struct ARROW_EXPORT BinaryViewScalar : public BaseBinaryScalar {
+  using BaseBinaryScalar::BaseBinaryScalar;
+  using TypeClass = BinaryViewType;
+
+  explicit BinaryViewScalar(std::shared_ptr<Buffer> value)
+      : BinaryViewScalar(std::move(value), binary_view()) {}
+
+  explicit BinaryViewScalar(std::string s)
+      : BaseBinaryScalar(std::move(s), binary_view()) {}
+
+  BinaryViewScalar() : BinaryViewScalar(binary_view()) {}
+
+  std::string_view view() const override { return std::string_view(*this->value); }
+};
+
+struct ARROW_EXPORT StringViewScalar : public BinaryViewScalar {
+  using BinaryViewScalar::BinaryViewScalar;
+  using TypeClass = StringViewType;
+
+  explicit StringViewScalar(std::shared_ptr<Buffer> value)
+      : StringViewScalar(std::move(value), utf8_view()) {}
+
+  explicit StringViewScalar(std::string s)
+      : BinaryViewScalar(std::move(s), utf8_view()) {}
+
+  StringViewScalar() : StringViewScalar(utf8_view()) {}
+};
+
 struct ARROW_EXPORT LargeBinaryScalar : public BaseBinaryScalar {
   using BaseBinaryScalar::BaseBinaryScalar;
   using TypeClass = LargeBinaryType;
@@ -296,7 +323,8 @@ struct ARROW_EXPORT LargeBinaryScalar : public BaseBinaryScalar {
   explicit LargeBinaryScalar(std::shared_ptr<Buffer> value)
       : LargeBinaryScalar(std::move(value), large_binary()) {}
 
-  explicit LargeBinaryScalar(std::string s);
+  explicit LargeBinaryScalar(std::string s)
+      : BaseBinaryScalar(std::move(s), large_binary()) {}
 
   LargeBinaryScalar() : LargeBinaryScalar(large_binary()) {}
 };
@@ -308,7 +336,8 @@ struct ARROW_EXPORT LargeStringScalar : public LargeBinaryScalar {
   explicit LargeStringScalar(std::shared_ptr<Buffer> value)
       : LargeStringScalar(std::move(value), large_utf8()) {}
 
-  explicit LargeStringScalar(std::string s);
+  explicit LargeStringScalar(std::string s)
+      : LargeBinaryScalar(std::move(s), large_utf8()) {}
 
   LargeStringScalar() : LargeStringScalar(large_utf8()) {}
 };
diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h
index 13fc0b3e81d..35b60174178 100644
--- a/cpp/src/arrow/testing/gtest_util.h
+++ b/cpp/src/arrow/testing/gtest_util.h
@@ -176,10 +176,17 @@ using DecimalArrowTypes = ::testing::Types<Decimal128Type, Decimal256Type>;
 using BaseBinaryArrowTypes =
     ::testing::Types<BinaryType, LargeBinaryType, StringType, LargeStringType>;
 
+using BaseBinaryOrBinaryViewLikeArrowTypes =
+    ::testing::Types<BinaryType, LargeBinaryType, BinaryViewType, StringType,
+                     LargeStringType, StringViewType>;
+
 using BinaryArrowTypes = ::testing::Types<BinaryType, LargeBinaryType>;
 
 using StringArrowTypes = ::testing::Types<StringType, LargeStringType>;
 
+using StringOrStringViewArrowTypes =
+    ::testing::Types<StringType, LargeStringType, StringViewType>;
+
 using ListArrowTypes = ::testing::Types<ListType, LargeListType>;
 
 using UnionArrowTypes = ::testing::Types<SparseUnionType, DenseUnionType>;
diff --git a/cpp/src/arrow/testing/json_internal.cc b/cpp/src/arrow/testing/json_internal.cc
index babff621b1f..b97a103c2b1 100644
--- a/cpp/src/arrow/testing/json_internal.cc
+++ b/cpp/src/arrow/testing/json_internal.cc
@@ -46,6 +46,8 @@
 #include "arrow/util/formatting.h"
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging.h"
+#include "arrow/util/range.h"
+#include "arrow/util/span.h"
 #include "arrow/util/string.h"
 #include "arrow/util/value_parsing.h"
 #include "arrow/visit_array_inline.h"
@@ -105,6 +107,11 @@ std::string GetTimeUnitName(TimeUnit::type unit) {
   return "UNKNOWN";
 }
 
+std::string_view GetStringView(const rj::Value& str) {
+  DCHECK(str.IsString());
+  return {str.GetString(), str.GetStringLength()};
+}
+
 class SchemaWriter {
  public:
   explicit SchemaWriter(const Schema& schema, const DictionaryFieldMapper& mapper,
@@ -227,8 +234,9 @@ class SchemaWriter {
 
   template <typename T>
   enable_if_t<is_null_type<T>::value || is_primitive_ctype<T>::value ||
-              is_base_binary_type<T>::value || is_base_list_type<T>::value ||
-              is_struct_type<T>::value || is_run_end_encoded_type<T>::value>
+              is_base_binary_type<T>::value || is_binary_view_like_type<T>::value ||
+              is_base_list_type<T>::value || is_struct_type<T>::value ||
+              is_run_end_encoded_type<T>::value>
   WriteTypeMetadata(const T& type) {}
 
   void WriteTypeMetadata(const MapType& type) {
@@ -386,6 +394,8 @@ class SchemaWriter {
   Status Visit(const TimeType& type) { return WritePrimitive("time", type); }
   Status Visit(const StringType& type) { return WriteVarBytes("utf8", type); }
   Status Visit(const BinaryType& type) { return WriteVarBytes("binary", type); }
+  Status Visit(const StringViewType& type) { return WritePrimitive("utf8view", type); }
+  Status Visit(const BinaryViewType& type) { return WritePrimitive("binaryview", type); }
   Status Visit(const LargeStringType& type) { return WriteVarBytes("largeutf8", type); }
   Status Visit(const LargeBinaryType& type) { return WriteVarBytes("largebinary", type); }
   Status Visit(const FixedSizeBinaryType& type) {
@@ -532,22 +542,19 @@ class ArrayWriter {
     }
   }
 
-  // Binary, encode to hexadecimal.
-  template <typename ArrayType>
-  enable_if_binary_like<typename ArrayType::TypeClass> WriteDataValues(
-      const ArrayType& arr) {
-    for (int64_t i = 0; i < arr.length(); ++i) {
-      writer_->String(HexEncode(arr.GetView(i)));
-    }
-  }
-
-  // UTF8 string, write as is
-  template <typename ArrayType>
-  enable_if_string_like<typename ArrayType::TypeClass> WriteDataValues(
-      const ArrayType& arr) {
+  template <typename ArrayType, typename Type = typename ArrayType::TypeClass>
+  std::enable_if_t<is_base_binary_type<Type>::value ||
+                   is_fixed_size_binary_type<Type>::value>
+  WriteDataValues(const ArrayType& arr) {
     for (int64_t i = 0; i < arr.length(); ++i) {
-      auto view = arr.GetView(i);
-      writer_->String(view.data(), static_cast<rj::SizeType>(view.size()));
+      if constexpr (Type::is_utf8) {
+        // UTF8 string, write as is
+        auto view = arr.GetView(i);
+        writer_->String(view.data(), static_cast<rj::SizeType>(view.size()));
+      } else {
+        // Binary, encode to hexadecimal.
+        writer_->String(HexEncode(arr.GetView(i)));
+      }
     }
   }
 
@@ -646,6 +653,48 @@ class ArrayWriter {
     writer_->EndArray();
   }
 
+  template <typename ArrayType, bool IsUtf8 = ArrayType::TypeClass::is_utf8>
+  void WriteStringHeaderField(const ArrayType& array) {
+    writer_->Key(kData);
+    writer_->StartArray();
+    for (int64_t i = 0; i < array.length(); ++i) {
+      auto s = array.raw_values()[i];
+      writer_->StartObject();
+      writer_->Key("SIZE");
+      writer_->Int64(s.size());
+      if (s.IsInline()) {
+        writer_->Key("INLINED");
+        if constexpr (IsUtf8) {
+          writer_->String(s.GetInlineData(), StringHeader::kInlineSize);
+        } else {
+          writer_->String(HexEncode(s.GetInlineData(), StringHeader::kInlineSize));
+        }
+      } else {
+        writer_->Key("PREFIX");
+        writer_->String(HexEncode(s.GetPrefix().data(), StringHeader::kPrefixSize));
+        writer_->Key("BUFFER_INDEX");
+        writer_->Int64(s.GetBufferIndex());
+        writer_->Key("OFFSET");
+        writer_->Int64(s.GetBufferOffset());
+      }
+      writer_->EndObject();
+    }
+    writer_->EndArray();
+  }
+
+  void WriteVariadicBuffersField(const BinaryViewArray& arr) {
+    writer_->Key("VARIADIC_BUFFERS");
+    writer_->StartArray();
+    const auto& buffers = arr.data()->buffers;
+    for (size_t i = 2; i < buffers.size(); ++i) {
+      // Encode the character buffers into hexadecimal strings.
+      // Even for arrays which contain utf-8, portions of the buffer not
+      // referenced by any view may be invalid.
+      writer_->String(buffers[i]->ToHexString());
+    }
+    writer_->EndArray();
+  }
+
   void WriteValidityField(const Array& arr) {
     writer_->Key("VALIDITY");
     writer_->StartArray();
@@ -686,8 +735,10 @@ class ArrayWriter {
   }
 
   template <typename ArrayType>
-  enable_if_t<std::is_base_of<PrimitiveArray, ArrayType>::value, Status> Visit(
-      const ArrayType& array) {
+  enable_if_t<std::is_base_of<PrimitiveArray, ArrayType>::value &&
+                  !is_binary_view_like_type<typename ArrayType::TypeClass>::value,
+              Status>
+  Visit(const ArrayType& array) {
     WriteValidityField(array);
     WriteDataField(array);
     SetNoChildren();
@@ -704,6 +755,21 @@ class ArrayWriter {
     return Status::OK();
   }
 
+  template <typename ArrayType>
+  enable_if_binary_view_like<typename ArrayType::TypeClass, Status> Visit(
+      const ArrayType& array) {
+    if (array.has_raw_pointers()) {
+      return Status::NotImplemented("serialization of ", array.type()->ToString());
+    }
+
+    WriteValidityField(array);
+    WriteStringHeaderField(array);
+    WriteVariadicBuffersField(array);
+
+    SetNoChildren();
+    return Status::OK();
+  }
+
   Status Visit(const DictionaryArray& array) {
     return VisitArrayValues(*array.indices());
   }
@@ -1065,6 +1131,10 @@ Status GetType(const RjObject& json_type,
     *type = utf8();
   } else if (type_name == "binary") {
     *type = binary();
+  } else if (type_name == "utf8view") {
+    *type = utf8_view();
+  } else if (type_name == "binaryview") {
+    *type = binary_view();
   } else if (type_name == "largeutf8") {
     *type = large_utf8();
   } else if (type_name == "largebinary") {
@@ -1341,7 +1411,7 @@ class ArrayReader {
       int64_t offset_end = ParseOffset(json_offsets[i + 1]);
       DCHECK(offset_end >= offset_start);
 
-      if (T::is_utf8) {
+      if constexpr (T::is_utf8) {
         auto str = val.GetString();
         DCHECK(std::string(str).size() == static_cast<size_t>(offset_end - offset_start));
         RETURN_NOT_OK(builder.Append(str));
@@ -1367,6 +1437,93 @@ class ArrayReader {
     return FinishBuilder(&builder);
   }
 
+  template <typename ViewType>
+  enable_if_binary_view_like<ViewType, Status> Visit(const ViewType& type) {
+    ARROW_ASSIGN_OR_RAISE(const auto json_views, GetDataArray(obj_));
+    ARROW_ASSIGN_OR_RAISE(const auto json_variadic_bufs,
+                          GetMemberArray(obj_, "VARIADIC_BUFFERS"));
+
+    using internal::Zip;
+    using util::span;
+
+    BufferVector buffers;
+    buffers.resize(json_variadic_bufs.Size() + 2);
+    for (auto [json_buf, buf] : Zip(json_variadic_bufs, span{buffers}.subspan(2))) {
+      auto hex_string = GetStringView(json_buf);
+      ARROW_ASSIGN_OR_RAISE(
+          buf, AllocateBuffer(static_cast<int64_t>(hex_string.size()) / 2, pool_));
+      RETURN_NOT_OK(ParseHexValues(hex_string, buf->mutable_data()));
+    }
+
+    TypedBufferBuilder<bool> validity_builder{pool_};
+    RETURN_NOT_OK(validity_builder.Resize(length_));
+    for (bool is_valid : is_valid_) {
+      validity_builder.UnsafeAppend(is_valid);
+    }
+    ARROW_ASSIGN_OR_RAISE(buffers[0], validity_builder.Finish());
+
+    ARROW_ASSIGN_OR_RAISE(buffers[1],
+                          AllocateBuffer(length_ * sizeof(StringHeader), pool_));
+
+    span headers{buffers[1]->mutable_data_as<StringHeader>(),
+                 static_cast<size_t>(length_)};
+
+    int64_t null_count = 0;
+    for (auto [json_view, header, is_valid] : Zip(json_views, headers, is_valid_)) {
+      if (!is_valid) {
+        header = {};
+        ++null_count;
+        continue;
+      }
+
+      DCHECK(json_view.IsObject());
+      const auto& json_view_obj = json_view.GetObject();
+
+      auto json_size = json_view_obj.FindMember("SIZE");
+      RETURN_NOT_INT("SIZE", json_size, json_view_obj);
+      auto size = static_cast<uint32_t>(json_size->value.GetInt64());
+
+      if (StringHeader::IsInline(size)) {
+        auto json_inlined = json_view_obj.FindMember("INLINED");
+        RETURN_NOT_STRING("INLINED", json_inlined, json_view_obj);
+        if constexpr (ViewType::is_utf8) {
+          DCHECK_EQ(json_inlined->value.GetStringLength(), StringHeader::kInlineSize);
+          header = StringHeader{json_inlined->value.GetString(), size};
+        } else {
+          DCHECK_EQ(json_inlined->value.GetStringLength(), StringHeader::kInlineSize * 2);
+          std::array<char, StringHeader::kInlineSize> inlined;
+          RETURN_NOT_OK(ParseHexValues(GetStringView(json_inlined->value),
+                                       reinterpret_cast<uint8_t*>(inlined.data())));
+          header = StringHeader{inlined.data(), size};
+        }
+        continue;
+      }
+
+      auto json_prefix = json_view_obj.FindMember("PREFIX");
+      auto json_buffer_index = json_view_obj.FindMember("BUFFER_INDEX");
+      auto json_offset = json_view_obj.FindMember("OFFSET");
+      RETURN_NOT_STRING("PREFIX", json_prefix, json_view_obj);
+      RETURN_NOT_INT("BUFFER_INDEX", json_buffer_index, json_view_obj);
+      RETURN_NOT_INT("OFFSET", json_offset, json_view_obj);
+
+      std::array<char, StringHeader::kPrefixSize> prefix;
+      DCHECK_EQ(json_prefix->value.GetStringLength(), StringHeader::kPrefixSize * 2);
+      RETURN_NOT_OK(ParseHexValues(GetStringView(json_prefix->value),
+                                   reinterpret_cast<uint8_t*>(prefix.data())));
+
+      header = StringHeader{size, prefix,
+                            static_cast<uint32_t>(json_buffer_index->value.GetInt64()),
+                            static_cast<uint32_t>(json_offset->value.GetInt64())};
+
+      DCHECK_LE(header.GetBufferIndex(), buffers.size() - 2);
+      DCHECK_LE(static_cast<int64_t>(header.GetBufferOffset() + header.size()),
+                buffers[header.GetBufferIndex() + 2]->size());
+    }
+
+    data_ = ArrayData::Make(type_, length_, std::move(buffers), null_count);
+    return Status::OK();
+  }
+
   Status Visit(const DayTimeIntervalType& type) {
     DayTimeIntervalBuilder builder(pool_);
 
diff --git a/cpp/src/arrow/testing/random.cc b/cpp/src/arrow/testing/random.cc
index b8ea247a437..33b618b4a23 100644
--- a/cpp/src/arrow/testing/random.cc
+++ b/cpp/src/arrow/testing/random.cc
@@ -362,13 +362,12 @@ std::shared_ptr<Array> RandomArrayGenerator::Decimal256(std::shared_ptr<DataType
   return gen.MakeRandomArray(size, null_probability, alignment, memory_pool);
 }
 
-template <typename TypeClass>
+template <typename TypeClass, typename offset_type = typename TypeClass::offset_type>
 static std::shared_ptr<Array> GenerateBinaryArray(RandomArrayGenerator* gen, int64_t size,
                                                   int32_t min_length, int32_t max_length,
                                                   double null_probability,
                                                   int64_t alignment,
                                                   MemoryPool* memory_pool) {
-  using offset_type = typename TypeClass::offset_type;
   using BuilderType = typename TypeTraits<TypeClass>::BuilderType;
   using OffsetArrowType = typename CTypeTraits<offset_type>::ArrowType;
   using OffsetArrayType = typename TypeTraits<OffsetArrowType>::ArrayType;
@@ -386,7 +385,7 @@ static std::shared_ptr<Array> GenerateBinaryArray(RandomArrayGenerator* gen, int
                  /*null_probability=*/0);
 
   std::vector<uint8_t> str_buffer(max_length);
-  BuilderType builder(memory_pool, alignment);
+  BuilderType builder{memory_pool, alignment};
 
   for (int64_t i = 0; i < size; ++i) {
     if (lengths->IsValid(i)) {
@@ -429,6 +428,15 @@ std::shared_ptr<Array> RandomArrayGenerator::BinaryWithRepeats(
   return *strings->View(binary());
 }
 
+std::shared_ptr<Array> RandomArrayGenerator::StringView(int64_t size, int32_t min_length,
+                                                        int32_t max_length,
+                                                        double null_probability,
+                                                        int64_t alignment,
+                                                        MemoryPool* memory_pool) {
+  return GenerateBinaryArray<StringViewType, uint32_t>(
+      this, size, min_length, max_length, null_probability, alignment, memory_pool);
+}
+
 std::shared_ptr<Array> RandomArrayGenerator::StringWithRepeats(
     int64_t size, int64_t unique, int32_t min_length, int32_t max_length,
     double null_probability, int64_t alignment, MemoryPool* memory_pool) {
@@ -842,6 +850,23 @@ std::shared_ptr<Array> RandomArrayGenerator::ArrayOf(const Field& field, int64_t
                   ->View(field.type());
     }
 
+    case Type::type::STRING_VIEW:
+    case Type::type::BINARY_VIEW: {
+      const auto min_length =
+          GetMetadata<int32_t>(field.metadata().get(), "min_length", 0);
+      const auto max_length =
+          GetMetadata<int32_t>(field.metadata().get(), "max_length", 20);
+
+      auto out = StringView(length, min_length, max_length, null_probability, alignment);
+
+      if (internal::checked_cast<const BinaryViewType&>(*field.type())
+              .has_raw_pointers()) {
+        ABORT_NOT_OK(internal::SwapStringHeaderPointers(
+            *out->data(), out->data()->buffers[1]->mutable_data_as<StringHeader>()));
+      }
+      return out->View(field.type()).ValueOrDie();
+    }
+
     case Type::type::DECIMAL128:
       return Decimal128(field.type(), length, null_probability, alignment, memory_pool);
 
diff --git a/cpp/src/arrow/testing/random.h b/cpp/src/arrow/testing/random.h
index 1bd189c39c2..999afdc60fd 100644
--- a/cpp/src/arrow/testing/random.h
+++ b/cpp/src/arrow/testing/random.h
@@ -367,6 +367,22 @@ class ARROW_TESTING_EXPORT RandomArrayGenerator {
                                 int64_t alignment = kDefaultBufferAlignment,
                                 MemoryPool* memory_pool = default_memory_pool());
 
+  /// \brief Generate a random StringViewArray
+  ///
+  /// \param[in] size the size of the array to generate
+  /// \param[in] min_length the lower bound of the string length
+  ///            determined by the uniform distribution
+  /// \param[in] max_length the upper bound of the string length
+  ///            determined by the uniform distribution
+  /// \param[in] alignment alignment for memory allocations (in bytes)
+  /// \param[in] null_probability the probability of a value being null
+  ///
+  /// \return a generated Array
+  std::shared_ptr<Array> StringView(int64_t size, int32_t min_length, int32_t max_length,
+                                    double null_probability = 0,
+                                    int64_t alignment = kDefaultBufferAlignment,
+                                    MemoryPool* memory_pool = default_memory_pool());
+
   /// \brief Generate a random LargeStringArray
   ///
   /// \param[in] size the size of the array to generate
diff --git a/cpp/src/arrow/testing/random_test.cc b/cpp/src/arrow/testing/random_test.cc
index 2f6d6354b28..cff6cdd1354 100644
--- a/cpp/src/arrow/testing/random_test.cc
+++ b/cpp/src/arrow/testing/random_test.cc
@@ -160,6 +160,7 @@ auto values = ::testing::Values(
     field("uint32", uint32()), field("int32", int32()), field("uint64", uint64()),
     field("int64", int64()), field("float16", float16()), field("float32", float32()),
     field("float64", float64()), field("string", utf8()), field("binary", binary()),
+    field("string_view", utf8_view()), field("binary_view", binary_view()),
     field("fixed_size_binary", fixed_size_binary(8)),
     field("decimal128", decimal128(8, 3)), field("decimal128", decimal128(29, -5)),
     field("decimal256", decimal256(16, 4)), field("decimal256", decimal256(57, -6)),
diff --git a/cpp/src/arrow/testing/util.h b/cpp/src/arrow/testing/util.h
index 4f4b03438fd..703593450e8 100644
--- a/cpp/src/arrow/testing/util.h
+++ b/cpp/src/arrow/testing/util.h
@@ -53,6 +53,14 @@ Status CopyBufferFromVector(const std::vector<T>& values, MemoryPool* pool,
   return Status::OK();
 }
 
+template <typename T>
+Result<std::shared_ptr<Buffer>> CopyBufferFromVector(
+    const std::vector<T>& values, MemoryPool* pool = default_memory_pool()) {
+  std::shared_ptr<Buffer> out;
+  RETURN_NOT_OK(CopyBufferFromVector(values, pool, &out));
+  return out;
+}
+
 // Sets approximately pct_null of the first n bytes in null_bytes to zero
 // and the rest to non-zero (true) values.
 ARROW_TESTING_EXPORT void random_null_bytes(int64_t n, double pct_null,
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 68dc2aabe96..e6125aae368 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -60,10 +60,14 @@ constexpr Type::type FixedSizeListType::type_id;
 
 constexpr Type::type BinaryType::type_id;
 
+constexpr Type::type BinaryViewType::type_id;
+
 constexpr Type::type LargeBinaryType::type_id;
 
 constexpr Type::type StringType::type_id;
 
+constexpr Type::type StringViewType::type_id;
+
 constexpr Type::type LargeStringType::type_id;
 
 constexpr Type::type FixedSizeBinaryType::type_id;
@@ -126,6 +130,8 @@ std::vector<Type::type> AllTypeIds() {
           Type::BINARY,
           Type::LARGE_STRING,
           Type::LARGE_BINARY,
+          Type::STRING_VIEW,
+          Type::BINARY_VIEW,
           Type::FIXED_SIZE_BINARY,
           Type::STRUCT,
           Type::LIST,
@@ -190,7 +196,9 @@ std::string ToString(Type::type id) {
     TO_STRING_CASE(INTERVAL_MONTHS)
     TO_STRING_CASE(DURATION)
     TO_STRING_CASE(STRING)
+    TO_STRING_CASE(STRING_VIEW)
     TO_STRING_CASE(BINARY)
+    TO_STRING_CASE(BINARY_VIEW)
     TO_STRING_CASE(LARGE_STRING)
     TO_STRING_CASE(LARGE_BINARY)
     TO_STRING_CASE(FIXED_SIZE_BINARY)
@@ -593,10 +601,18 @@ std::string FixedSizeListType::ToString() const {
 
 std::string BinaryType::ToString() const { return "binary"; }
 
+std::string BinaryViewType::ToString() const {
+  return raw_pointers_ ? "binary_view[RAW POINTERS]" : "binary_view";
+}
+
 std::string LargeBinaryType::ToString() const { return "large_binary"; }
 
 std::string StringType::ToString() const { return "string"; }
 
+std::string StringViewType::ToString() const {
+  return raw_pointers_ ? "string_view[RAW POINTERS]" : "string_view";
+}
+
 std::string LargeStringType::ToString() const { return "large_string"; }
 
 int FixedSizeBinaryType::bit_width() const { return CHAR_BIT * byte_width(); }
@@ -2320,8 +2336,10 @@ PARAMETER_LESS_FINGERPRINT(HalfFloat)
 PARAMETER_LESS_FINGERPRINT(Float)
 PARAMETER_LESS_FINGERPRINT(Double)
 PARAMETER_LESS_FINGERPRINT(Binary)
+PARAMETER_LESS_FINGERPRINT(BinaryView)
 PARAMETER_LESS_FINGERPRINT(LargeBinary)
 PARAMETER_LESS_FINGERPRINT(String)
+PARAMETER_LESS_FINGERPRINT(StringView)
 PARAMETER_LESS_FINGERPRINT(LargeString)
 PARAMETER_LESS_FINGERPRINT(Date32)
 PARAMETER_LESS_FINGERPRINT(Date64)
@@ -2533,6 +2551,18 @@ TYPE_FACTORY(large_binary, LargeBinaryType)
 TYPE_FACTORY(date64, Date64Type)
 TYPE_FACTORY(date32, Date32Type)
 
+const std::shared_ptr<DataType>& utf8_view(bool has_raw_pointers) {
+  static std::shared_ptr<DataType> io = std::make_shared<StringViewType>();
+  static std::shared_ptr<DataType> raw = std::make_shared<StringViewType>(true);
+  return has_raw_pointers ? raw : io;
+}
+
+const std::shared_ptr<DataType>& binary_view(bool has_raw_pointers) {
+  static std::shared_ptr<DataType> io = std::make_shared<BinaryViewType>();
+  static std::shared_ptr<DataType> raw = std::make_shared<BinaryViewType>(true);
+  return has_raw_pointers ? raw : io;
+}
+
 std::shared_ptr<DataType> fixed_size_binary(int32_t byte_width) {
   return std::make_shared<FixedSizeBinaryType>(byte_width);
 }
@@ -2782,7 +2812,7 @@ void InitStaticData() {
   // * Time32
   // * Time64
   // * Timestamp
-  g_primitive_types = {null(), boolean(), date32(), date64()};
+  g_primitive_types = {null(), boolean(), date32(), date64(), binary_view(), utf8_view()};
   Extend(g_numeric_types, &g_primitive_types);
   Extend(g_base_binary_types, &g_primitive_types);
 }
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index 48228d43ef9..a77168cf43d 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -23,6 +23,7 @@
 #include <iosfwd>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <variant>
@@ -33,6 +34,7 @@
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/endian.h"
 #include "arrow/util/macros.h"
+#include "arrow/util/string_header.h"
 #include "arrow/util/visibility.h"
 #include "arrow/visitor.h"  // IWYU pragma: keep
 
@@ -113,8 +115,14 @@ struct ARROW_EXPORT DataTypeLayout {
   std::vector<BufferSpec> buffers;
   /// Whether this type expects an associated dictionary array.
   bool has_dictionary = false;
+  /// If this is provided, the number of buffers expected is only lower-bounded by
+  /// buffers.size(). Buffers beyond this lower bound are expected to conform to
+  /// variadic_spec.
+  std::optional<BufferSpec> variadic_spec;
 
-  explicit DataTypeLayout(std::vector<BufferSpec> v) : buffers(std::move(v)) {}
+  explicit DataTypeLayout(std::vector<BufferSpec> buffers,
+                          std::optional<BufferSpec> variadic_spec = {})
+      : buffers(std::move(buffers)), variadic_spec(variadic_spec) {}
 };
 
 /// \brief Base class for all data types
@@ -710,6 +718,40 @@ class ARROW_EXPORT BinaryType : public BaseBinaryType {
   explicit BinaryType(Type::type logical_type) : BaseBinaryType(logical_type) {}
 };
 
+/// \brief Concrete type class for variable-size binary view data using
+/// StringHeader structs
+class ARROW_EXPORT BinaryViewType : public DataType {
+ public:
+  static constexpr Type::type type_id = Type::BINARY_VIEW;
+  static constexpr bool is_utf8 = false;
+  using PhysicalType = BinaryViewType;
+
+  static constexpr const char* type_name() { return "binary_view"; }
+
+  explicit BinaryViewType(bool has_raw_pointers = false)
+      : BinaryViewType(Type::BINARY_VIEW, has_raw_pointers) {}
+
+  DataTypeLayout layout() const override {
+    return DataTypeLayout(
+        {DataTypeLayout::Bitmap(), DataTypeLayout::FixedWidth(sizeof(StringHeader))},
+        DataTypeLayout::VariableWidth());
+  }
+
+  std::string ToString() const override;
+  std::string name() const override { return "binary_view"; }
+
+  bool has_raw_pointers() const { return raw_pointers_; }
+
+ protected:
+  std::string ComputeFingerprint() const override;
+
+  // Allow subclasses like StringType to change the logical type.
+  explicit BinaryViewType(Type::type logical_type, bool has_raw_pointers)
+      : DataType(logical_type), raw_pointers_(has_raw_pointers) {}
+
+  bool raw_pointers_ = false;
+};
+
 /// \brief Concrete type class for large variable-size binary data
 class ARROW_EXPORT LargeBinaryType : public BaseBinaryType {
  public:
@@ -756,6 +798,25 @@ class ARROW_EXPORT StringType : public BinaryType {
   std::string ComputeFingerprint() const override;
 };
 
+/// \brief Concrete type class for variable-size string data, utf8-encoded
+class ARROW_EXPORT StringViewType : public BinaryViewType {
+ public:
+  static constexpr Type::type type_id = Type::STRING_VIEW;
+  static constexpr bool is_utf8 = true;
+  using PhysicalType = BinaryViewType;
+
+  static constexpr const char* type_name() { return "utf8_view"; }
+
+  explicit StringViewType(bool has_raw_pointers = false)
+      : BinaryViewType(Type::STRING_VIEW, has_raw_pointers) {}
+
+  std::string ToString() const override;
+  std::string name() const override { return "utf8_view"; }
+
+ protected:
+  std::string ComputeFingerprint() const override;
+};
+
 /// \brief Concrete type class for large variable-size string data, utf8-encoded
 class ARROW_EXPORT LargeStringType : public LargeBinaryType {
  public:
diff --git a/cpp/src/arrow/type_fwd.h b/cpp/src/arrow/type_fwd.h
index 657abbaecc4..c0569fc091f 100644
--- a/cpp/src/arrow/type_fwd.h
+++ b/cpp/src/arrow/type_fwd.h
@@ -108,6 +108,11 @@ class BinaryArray;
 class BinaryBuilder;
 struct BinaryScalar;
 
+class BinaryViewType;
+class BinaryViewArray;
+class BinaryViewBuilder;
+struct BinaryViewScalar;
+
 class LargeBinaryType;
 class LargeBinaryArray;
 class LargeBinaryBuilder;
@@ -123,6 +128,11 @@ class StringArray;
 class StringBuilder;
 struct StringScalar;
 
+class StringViewType;
+class StringViewArray;
+class StringViewBuilder;
+struct StringViewScalar;
+
 class LargeStringType;
 class LargeStringArray;
 class LargeStringBuilder;
@@ -413,6 +423,13 @@ struct Type {
     /// Run-end encoded data.
     RUN_END_ENCODED,
 
+    /// String (UTF8) view type with 4-byte prefix and inline small string
+    /// optimization
+    STRING_VIEW,
+
+    /// Bytes view type with 4-byte prefix and inline small string optimization
+    BINARY_VIEW,
+
     // Leave this at the end
     MAX_ID
   };
@@ -454,10 +471,14 @@ ARROW_EXPORT const std::shared_ptr<DataType>& float32();
 ARROW_EXPORT const std::shared_ptr<DataType>& float64();
 /// \brief Return a StringType instance
 ARROW_EXPORT const std::shared_ptr<DataType>& utf8();
+/// \brief Return a StringViewType instance
+ARROW_EXPORT const std::shared_ptr<DataType>& utf8_view(bool has_raw_pointers = false);
 /// \brief Return a LargeStringType instance
 ARROW_EXPORT const std::shared_ptr<DataType>& large_utf8();
 /// \brief Return a BinaryType instance
 ARROW_EXPORT const std::shared_ptr<DataType>& binary();
+/// \brief Return a BinaryViewType instance
+ARROW_EXPORT const std::shared_ptr<DataType>& binary_view(bool has_raw_pointers = false);
 /// \brief Return a LargeBinaryType instance
 ARROW_EXPORT const std::shared_ptr<DataType>& large_binary();
 /// \brief Return a Date32Type instance
diff --git a/cpp/src/arrow/type_test.cc b/cpp/src/arrow/type_test.cc
index 3c83da9f2e6..93e7e6a5f9d 100644
--- a/cpp/src/arrow/type_test.cc
+++ b/cpp/src/arrow/type_test.cc
@@ -1045,9 +1045,21 @@ TEST(TestBinaryType, ToString) {
 TEST(TestStringType, ToString) {
   StringType str;
   ASSERT_EQ(str.id(), Type::STRING);
+  ASSERT_EQ(str.name(), std::string("utf8"));
+  ASSERT_EQ(str.type_name(), std::string("utf8"));
   ASSERT_EQ(str.ToString(), std::string("string"));
 }
 
+TEST(TestBinaryViewType, ToString) {
+  BinaryViewType t1;
+  BinaryViewType e1;
+  StringViewType t2;
+  AssertTypeEqual(t1, e1);
+  AssertTypeNotEqual(t1, t2);
+  ASSERT_EQ(t1.id(), Type::BINARY_VIEW);
+  ASSERT_EQ(t1.ToString(), std::string("binary_view"));
+}
+
 TEST(TestLargeBinaryTypes, ToString) {
   BinaryType bt1;
   LargeBinaryType t1;
diff --git a/cpp/src/arrow/type_traits.cc b/cpp/src/arrow/type_traits.cc
index ac16afe4b8c..de328f322ad 100644
--- a/cpp/src/arrow/type_traits.cc
+++ b/cpp/src/arrow/type_traits.cc
@@ -88,6 +88,8 @@ int RequiredValueAlignmentForBuffer(Type::type type_id, int buffer_index) {
     case Type::DURATION:
     case Type::INTERVAL_MONTH_DAY_NANO:  // Stored as two 32-bit integers and a 64-bit
                                          // integer
+    case Type::STRING_VIEW:
+    case Type::BINARY_VIEW:
       return 8;
     case Type::DICTIONARY:
     case Type::EXTENSION:
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index 7204fd6d85d..02426a33fb2 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -341,6 +341,16 @@ struct TypeTraits<BinaryType> {
   static inline std::shared_ptr<DataType> type_singleton() { return binary(); }
 };
 
+template <>
+struct TypeTraits<BinaryViewType> {
+  using ArrayType = BinaryViewArray;
+  using BuilderType = BinaryViewBuilder;
+  using ScalarType = BinaryViewScalar;
+  using CType = StringHeader;
+  constexpr static bool is_parameter_free = true;
+  static inline std::shared_ptr<DataType> type_singleton() { return binary_view(); }
+};
+
 template <>
 struct TypeTraits<LargeBinaryType> {
   using ArrayType = LargeBinaryArray;
@@ -371,6 +381,16 @@ struct TypeTraits<StringType> {
   static inline std::shared_ptr<DataType> type_singleton() { return utf8(); }
 };
 
+template <>
+struct TypeTraits<StringViewType> {
+  using ArrayType = StringViewArray;
+  using BuilderType = StringViewBuilder;
+  using ScalarType = StringViewScalar;
+  using CType = StringHeader;
+  constexpr static bool is_parameter_free = true;
+  static inline std::shared_ptr<DataType> type_singleton() { return utf8_view(); }
+};
+
 template <>
 struct TypeTraits<LargeStringType> {
   using ArrayType = LargeStringArray;
@@ -399,6 +419,11 @@ struct CTypeTraits<std::string> : public TypeTraits<StringType> {
   using ArrowType = StringType;
 };
 
+template <>
+struct CTypeTraits<StringHeader> : public TypeTraits<BinaryViewType> {
+  using ArrowType = BinaryViewType;
+};
+
 template <>
 struct CTypeTraits<const char*> : public CTypeTraits<std::string> {};
 
@@ -614,9 +639,28 @@ using is_string_type =
 template <typename T, typename R = void>
 using enable_if_string = enable_if_t<is_string_type<T>::value, R>;
 
+template <typename T>
+using is_binary_view_like_type = std::is_base_of<BinaryViewType, T>;
+
+template <typename T>
+using is_binary_view_type = std::is_same<BinaryViewType, T>;
+
+template <typename T>
+using is_string_view_type = std::is_same<StringViewType, T>;
+
+template <typename T, typename R = void>
+using enable_if_binary_view_like = enable_if_t<is_binary_view_like_type<T>::value, R>;
+
+template <typename T, typename R = void>
+using enable_if_binary_view = enable_if_t<is_binary_view_type<T>::value, R>;
+
+template <typename T, typename R = void>
+using enable_if_string_view = enable_if_t<is_string_view_type<T>::value, R>;
+
 template <typename T>
 using is_string_like_type =
-    std::integral_constant<bool, is_base_binary_type<T>::value && T::is_utf8>;
+    std::integral_constant<bool, (is_base_binary_type<T>::value && T::is_utf8) ||
+                                     is_string_view_type<T>::value>;
 
 template <typename T, typename R = void>
 using enable_if_string_like = enable_if_t<is_string_like_type<T>::value, R>;
@@ -639,10 +683,9 @@ template <typename T, typename R = void>
 using enable_if_fixed_width_type = enable_if_t<is_fixed_width_type<T>::value, R>;
 
 template <typename T>
-using is_binary_like_type =
-    std::integral_constant<bool, (is_base_binary_type<T>::value &&
-                                  !is_string_like_type<T>::value) ||
-                                     is_fixed_size_binary_type<T>::value>;
+using is_binary_like_type = std::integral_constant<
+    bool, (is_base_binary_type<T>::value && !is_string_like_type<T>::value) ||
+              is_binary_view_type<T>::value || is_fixed_size_binary_type<T>::value>;
 
 template <typename T, typename R = void>
 using enable_if_binary_like = enable_if_t<is_binary_like_type<T>::value, R>;
@@ -801,8 +844,10 @@ using enable_if_has_c_type = enable_if_t<has_c_type<T>::value, R>;
 template <typename T>
 using has_string_view =
     std::integral_constant<bool, std::is_same<BinaryType, T>::value ||
+                                     std::is_same<BinaryViewType, T>::value ||
                                      std::is_same<LargeBinaryType, T>::value ||
                                      std::is_same<StringType, T>::value ||
+                                     std::is_same<StringViewType, T>::value ||
                                      std::is_same<LargeStringType, T>::value ||
                                      std::is_same<FixedSizeBinaryType, T>::value>;
 
diff --git a/cpp/src/arrow/util/CMakeLists.txt b/cpp/src/arrow/util/CMakeLists.txt
index 4d364655787..719cad42aa4 100644
--- a/cpp/src/arrow/util/CMakeLists.txt
+++ b/cpp/src/arrow/util/CMakeLists.txt
@@ -111,3 +111,4 @@ add_arrow_benchmark(thread_pool_benchmark)
 add_arrow_benchmark(trie_benchmark)
 add_arrow_benchmark(utf8_util_benchmark)
 add_arrow_benchmark(value_parsing_benchmark)
+add_arrow_benchmark(string_conversion_benchmark)
diff --git a/cpp/src/arrow/util/range.h b/cpp/src/arrow/util/range.h
index ea0fb0eeaab..d80979c766a 100644
--- a/cpp/src/arrow/util/range.h
+++ b/cpp/src/arrow/util/range.h
@@ -21,11 +21,11 @@
 #include <cstdint>
 #include <iterator>
 #include <numeric>
+#include <tuple>
 #include <utility>
 #include <vector>
 
-namespace arrow {
-namespace internal {
+namespace arrow::internal {
 
 /// Create a vector containing the values from start up to stop
 template <typename T>
@@ -151,5 +151,55 @@ LazyRange<Generator> MakeLazyRange(Generator&& gen, int64_t length) {
   return LazyRange<Generator>(std::forward<Generator>(gen), length);
 }
 
-}  // namespace internal
-}  // namespace arrow
+/// \brief A helper for iterating multiple ranges simultaneously, modelled after python's
+/// built-in zip() function.
+///
+/// \code {.cpp}
+/// const std::vector<SomeTable>& tables = ...
+/// std::function<std::vector<std::string>()> GetNames = ...
+/// for (auto&& [table, name] : Zip(tables, GetNames())) {
+///   static_assert(std::is_same_v<decltype(table), const SomeTable&>);
+///   static_assert(std::is_same_v<decltype(name), std::string&>);
+///   // temporaries (like this vector of strings) are kept alive for the
+///   // duration of a loop and are safely movable).
+///   RegisterTableWithName(std::move(name), &table);
+/// }
+/// \endcode
+template <typename Ranges, typename Indices>
+struct Zip;
+
+template <typename... Ranges>
+Zip(Ranges&&...) -> Zip<std::tuple<Ranges...>, std::index_sequence_for<Ranges...>>;
+
+template <typename... Ranges, size_t... I>
+struct Zip<std::tuple<Ranges...>, std::index_sequence<I...>> {
+  explicit Zip(Ranges... ranges) : ranges_(std::forward<Ranges>(ranges)...) {}
+
+  std::tuple<Ranges...> ranges_;
+
+  using sentinel = std::tuple<decltype(std::get<I>(ranges_).end())...>;
+
+  struct iterator : std::tuple<decltype(std::get<I>(ranges_).begin())...> {
+    using std::tuple<decltype(std::get<I>(ranges_).begin())...>::tuple;
+
+    constexpr auto operator*() {
+      return std::tuple<decltype(*std::get<I>(*this))...>{*std::get<I>(*this)...};
+    }
+
+    constexpr iterator& operator++() {
+      (++std::get<I>(*this), ...);
+      return *this;
+    }
+
+    constexpr bool operator!=(const sentinel& s) const {
+      bool all_iterators_valid = (... && (std::get<I>(*this) != std::get<I>(s)));
+      return all_iterators_valid;
+    }
+  };
+
+  constexpr iterator begin() { return {std::get<I>(ranges_).begin()...}; }
+
+  constexpr sentinel end() { return {std::get<I>(ranges_).end()...}; }
+};
+
+}  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/sort.h b/cpp/src/arrow/util/sort.h
index cdffe0b2317..6b01998ab59 100644
--- a/cpp/src/arrow/util/sort.h
+++ b/cpp/src/arrow/util/sort.h
@@ -24,18 +24,24 @@
 #include <utility>
 #include <vector>
 
-namespace arrow {
-namespace internal {
+#include "arrow/util/span.h"
 
-template <typename T, typename Cmp = std::less<T>>
-std::vector<int64_t> ArgSort(const std::vector<T>& values, Cmp&& cmp = {}) {
-  std::vector<int64_t> indices(values.size());
+namespace arrow::internal {
+
+template <typename I = int64_t, typename T, typename Cmp = std::less<T>>
+std::vector<I> ArgSort(arrow::util::span<T> values, Cmp&& cmp = {}) {
+  std::vector<I> indices(values.size());
   std::iota(indices.begin(), indices.end(), 0);
   std::sort(indices.begin(), indices.end(),
-            [&](int64_t i, int64_t j) -> bool { return cmp(values[i], values[j]); });
+            [&](I i, I j) -> bool { return cmp(values[i], values[j]); });
   return indices;
 }
 
+template <typename I = int64_t, typename Range, typename... Cmp>
+std::vector<I> ArgSort(const Range& values, Cmp&&... cmp) {
+  return ArgSort(arrow::util::span{values}, std::forward<Cmp>(cmp)...);
+}
+
 template <typename T>
 size_t Permute(const std::vector<int64_t>& indices, std::vector<T>* values) {
   if (indices.size() <= 1) {
@@ -74,5 +80,4 @@ size_t Permute(const std::vector<int64_t>& indices, std::vector<T>* values) {
   return cycle_count;
 }
 
-}  // namespace internal
-}  // namespace arrow
+}  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/span.h b/cpp/src/arrow/util/span.h
new file mode 100644
index 00000000000..79ac3890e29
--- /dev/null
+++ b/cpp/src/arrow/util/span.h
@@ -0,0 +1,113 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+namespace arrow::util {
+
+/// std::span polyfill
+template <typename T>
+class span {
+  static_assert(sizeof(T),
+                R"(
+std::span allows contiguous_iterators instead of just pointers, the enforcement
+of which requires T to be a complete type. arrow::util::span does not support
+contiguous_iterators, but T is still required to be a complete type to prevent
+writing code which would break when it is replaced by std::span.)");
+
+ public:
+  using element_type = T;
+
+  span() = default;
+  span(const span&) = default;
+  span& operator=(const span&) = default;
+
+  template <typename M, typename = std::enable_if_t<std::is_same_v<T, M const>>>
+  // NOLINTNEXTLINE runtime/explicit
+  constexpr span(span<M> mut) : span{mut.data(), mut.size()} {}
+
+  constexpr span(T* data, std::size_t count) : data_{data}, size_{count} {}
+
+  constexpr span(T* begin, T* end)
+      : data_{begin}, size_{static_cast<std::size_t>(end - begin)} {}
+
+  template <typename R,
+            typename =
+                std::enable_if_t<std::is_same_v<decltype(std::declval<R&>().data()), T*>>,
+            typename = std::enable_if_t<
+                std::is_convertible_v<decltype(std::declval<R&>().size()), std::size_t>>>
+  // NOLINTNEXTLINE runtime/explicit, non-const reference
+  constexpr span(R& range) : span{range.data(), range.size()} {}
+
+  constexpr T* begin() const { return data_; }
+  constexpr T* end() const { return data_ + size_; }
+  constexpr T* data() const { return data_; }
+
+  constexpr std::size_t size() const { return size_; }
+  constexpr std::size_t size_bytes() const { return size_ * sizeof(T); }
+  constexpr bool empty() const { return size_ == 0; }
+
+  constexpr T& operator[](std::size_t i) { return data_[i]; }
+  constexpr const T& operator[](std::size_t i) const { return data_[i]; }
+
+  constexpr span subspan(std::size_t offset) const {
+    if (offset > size_) return {};
+    return {data_ + offset, size_ - offset};
+  }
+
+  constexpr span subspan(std::size_t offset, std::size_t count) const {
+    auto out = subspan(offset);
+    if (count < out.size_) {
+      out.size_ = count;
+    }
+    return out;
+  }
+
+  constexpr bool operator==(span const& other) const {
+    if (size_ != other.size_) return false;
+
+    T* ptr = data_;
+    for (T const& e : other) {
+      if (*ptr++ != e) return false;
+    }
+    return true;
+  }
+  constexpr bool operator!=(span const& other) const { return !(*this == other); }
+
+ private:
+  T* data_{};
+  std::size_t size_{};
+};
+
+template <typename R>
+span(R&) -> span<std::remove_pointer_t<decltype(std::declval<R>().data())>>;
+
+template <typename T>
+constexpr span<std::byte const> as_bytes(span<T> s) {
+  return {reinterpret_cast<std::byte const*>(s.data()), s.size_bytes()};
+}
+
+template <typename T>
+constexpr span<std::byte> as_writable_bytes(span<T> s) {
+  return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
+}
+
+}  // namespace arrow::util
diff --git a/cpp/src/arrow/util/string.cc b/cpp/src/arrow/util/string.cc
index 2055b4f47ea..07dfc2ce79f 100644
--- a/cpp/src/arrow/util/string.cc
+++ b/cpp/src/arrow/util/string.cc
@@ -90,6 +90,16 @@ Status ParseHexValue(const char* data, uint8_t* out) {
   return Status::OK();
 }
 
+Status ParseHexValues(std::string_view hex_string, uint8_t* out) {
+  if (hex_string.size() % 2 != 0) {
+    return Status::Invalid("Expected base16 hex string");
+  }
+  for (size_t j = 0; j < hex_string.size() / 2; ++j) {
+    RETURN_NOT_OK(ParseHexValue(hex_string.data() + j * 2, out + j));
+  }
+  return Status::OK();
+}
+
 namespace internal {
 
 std::vector<std::string_view> SplitString(std::string_view v, char delimiter,
diff --git a/cpp/src/arrow/util/string.h b/cpp/src/arrow/util/string.h
index d9777efc56a..d7e377773f6 100644
--- a/cpp/src/arrow/util/string.h
+++ b/cpp/src/arrow/util/string.h
@@ -46,7 +46,9 @@ ARROW_EXPORT std::string HexEncode(std::string_view str);
 
 ARROW_EXPORT std::string Escape(std::string_view str);
 
-ARROW_EXPORT Status ParseHexValue(const char* data, uint8_t* out);
+ARROW_EXPORT Status ParseHexValue(const char* hex_pair, uint8_t* out);
+
+ARROW_EXPORT Status ParseHexValues(std::string_view hex_string, uint8_t* out);
 
 namespace internal {
 
diff --git a/cpp/src/arrow/util/string_conversion_benchmark.cc b/cpp/src/arrow/util/string_conversion_benchmark.cc
new file mode 100644
index 00000000000..28a412a516f
--- /dev/null
+++ b/cpp/src/arrow/util/string_conversion_benchmark.cc
@@ -0,0 +1,252 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/util/unreachable.h"
+#include "arrow/visit_data_inline.h"
+#include "benchmark/benchmark.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+#include "arrow/array/array_binary.h"
+#include "arrow/array/builder_binary.h"
+#include "arrow/status.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/random.h"
+#include "arrow/type.h"
+#include "arrow/util/formatting.h"
+#include "arrow/util/key_value_metadata.h"
+#include "arrow/util/value_parsing.h"
+
+namespace arrow::internal {
+namespace {
+
+// Matrix of benchmarks:
+//
+// Direction:
+// - STRING <-> RAW VIEWS
+// - STRING <-> IO VIEWS
+// - IO VIEWS <-> RAW VIEWS
+//
+// View length:
+// - pure inline
+// - pure non-inline
+// - mixed with small mean length
+// - mixed with large mean length
+//
+// Character buffer count:
+// - ensure there are multiple 1MB buffers
+// - baseline with only a single character buffer?
+constexpr int kCharacterCount = (1 << 20) * 16;
+
+// Null counts?
+// Scrambled ordering?
+
+enum {
+  kStrings,
+  kRawPointerViews,
+  kIndexOffsetViews,
+};
+std::shared_ptr<DataType> DataTypeFor(decltype(kStrings) enm) {
+  switch (enm) {
+    case kStrings:
+      return utf8();
+    case kIndexOffsetViews:
+      return utf8_view();
+    case kRawPointerViews:
+      return utf8_view(/*has_raw_pointers=*/true);
+  }
+  Unreachable();
+}
+
+enum {
+  kAlwaysInlineable,
+  kUsuallyInlineable,
+  kShortButNeverInlineable,
+  kLongAndSeldomInlineable,
+  kLongAndNeverInlineable,
+};
+
+StringViewArray ToStringViewArray(const StringArray& arr) {
+  auto header_buffer = AllocateBuffer(arr.length() * sizeof(StringHeader)).ValueOrDie();
+
+  StringHeadersFromStrings(*arr.data(), header_buffer->mutable_data_as<StringHeader>());
+
+  return {arr.length(),
+          std::move(header_buffer),
+          {arr.value_data()},
+          arr.null_bitmap(),
+          arr.null_count()};
+}
+
+StringArray ToStringArray(const StringViewArray& arr) {
+  int64_t char_count = 0;
+  for (size_t i = 2; i < arr.data()->buffers.size(); ++i) {
+    char_count += arr.data()->buffers[i]->size();
+  }
+
+  auto offset_buffer = AllocateBuffer((arr.length() + 1) * sizeof(int32_t)).ValueOrDie();
+  auto* offset = offset_buffer->mutable_data_as<int32_t>();
+  offset[0] = 0;
+
+  BufferBuilder char_buffer_builder;
+  ABORT_NOT_OK(char_buffer_builder.Reserve(char_count));
+
+  ABORT_NOT_OK(VisitArraySpanInline<StringViewType>(
+      *arr.data(),
+      [&](std::string_view v) {
+        offset[1] = offset[0] + v.size();
+        ++offset;
+        return char_buffer_builder.Append(v);
+      },
+      [&] {
+        offset[1] = offset[0];
+        ++offset;
+        return Status::OK();
+      }));
+
+  auto char_buffer = char_buffer_builder.Finish().ValueOrDie();
+
+  return {arr.length(), std::move(offset_buffer), std::move(char_buffer),
+          arr.null_bitmap(), arr.null_count()};
+}
+
+std::shared_ptr<Buffer> ToRawPointers(const StringViewArray& io) {
+  auto raw_buf = AllocateBuffer(io.length() * sizeof(StringHeader)).ValueOrDie();
+  auto st =
+      SwapStringHeaderPointers(*io.data(), raw_buf->mutable_data_as<StringHeader>());
+  ABORT_NOT_OK(st);
+  return raw_buf;
+}
+
+std::shared_ptr<Buffer> ToIndexOffsets(const StringViewArray& raw) {
+  auto io_buf = AllocateBuffer(raw.length() * sizeof(StringHeader)).ValueOrDie();
+  auto st =
+      SwapStringHeaderPointers(*raw.data(), io_buf->mutable_data_as<StringHeader>());
+  ABORT_NOT_OK(st);
+  return io_buf;
+}
+
+template <auto From, auto To, auto StringLengthsAre>
+static void ConvertViews(benchmark::State& state) {  // NOLINT non-const reference
+  auto [min_length, max_length] = [] {
+    switch (StringLengthsAre) {
+      case kAlwaysInlineable:
+        return std::pair{0, 12};
+      case kUsuallyInlineable:
+        return std::pair{0, 16};
+      case kShortButNeverInlineable:
+        return std::pair{13, 30};
+      case kLongAndSeldomInlineable:
+        return std::pair{0, 256};
+      case kLongAndNeverInlineable:
+        return std::pair{13, 256};
+      default:
+        Unreachable();
+    }
+  }();
+
+  auto num_items = kCharacterCount / max_length;
+
+  auto from_type = DataTypeFor(From);
+  auto to_type = DataTypeFor(To);
+
+  auto from = random::GenerateArray(*field("", from_type,
+                                           key_value_metadata({
+                                               {"null_probability", "0"},
+                                               {"min_length", std::to_string(min_length)},
+                                               {"max_length", std::to_string(max_length)},
+                                           })),
+                                    num_items, 0xdeadbeef);
+
+  uint64_t dummy = 0;
+  for (auto _ : state) {
+    if constexpr (From == kStrings && To == kIndexOffsetViews) {
+      dummy += ToStringViewArray(checked_cast<const StringArray&>(*from)).length();
+    }
+
+    if constexpr (From == kIndexOffsetViews && To == kStrings) {
+      dummy += ToStringArray(checked_cast<const StringViewArray&>(*from)).length();
+    }
+
+    if constexpr (From == kIndexOffsetViews && To == kRawPointerViews) {
+      dummy += ToRawPointers(checked_cast<const StringViewArray&>(*from))->size();
+    }
+
+    if constexpr (From == kRawPointerViews && To == kIndexOffsetViews) {
+      dummy += ToIndexOffsets(checked_cast<const StringViewArray&>(*from))->size();
+    }
+
+    benchmark::DoNotOptimize(dummy);
+  }
+  state.SetItemsProcessed(state.iterations() * num_items);
+}
+
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kIndexOffsetViews, kAlwaysInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kIndexOffsetViews, kUsuallyInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kIndexOffsetViews, kShortButNeverInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kIndexOffsetViews, kLongAndSeldomInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kIndexOffsetViews, kLongAndNeverInlineable);
+
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kStrings, kAlwaysInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kStrings, kUsuallyInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kStrings, kShortButNeverInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kStrings, kLongAndSeldomInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kStrings, kLongAndNeverInlineable);
+
+/*
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kRawPointerViews, kAlwaysInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kRawPointerViews, kUsuallyInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kRawPointerViews, kShortButNeverInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kRawPointerViews, kLongAndSeldomInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kStrings, kRawPointerViews, kLongAndNeverInlineable);
+
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kStrings, kAlwaysInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kStrings, kUsuallyInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kStrings, kShortButNeverInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kStrings, kLongAndSeldomInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kStrings, kLongAndNeverInlineable);
+  */
+
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kIndexOffsetViews, kAlwaysInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kIndexOffsetViews, kUsuallyInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kIndexOffsetViews,
+                   kShortButNeverInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kIndexOffsetViews,
+                   kLongAndSeldomInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kRawPointerViews, kIndexOffsetViews,
+                   kLongAndNeverInlineable);
+
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kRawPointerViews, kAlwaysInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kRawPointerViews, kUsuallyInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kRawPointerViews,
+                   kShortButNeverInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kRawPointerViews,
+                   kLongAndSeldomInlineable);
+BENCHMARK_TEMPLATE(ConvertViews, kIndexOffsetViews, kRawPointerViews,
+                   kLongAndNeverInlineable);
+
+}  // namespace
+}  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/string_header.cc b/cpp/src/arrow/util/string_header.cc
new file mode 100644
index 00000000000..e12d4553b16
--- /dev/null
+++ b/cpp/src/arrow/util/string_header.cc
@@ -0,0 +1,29 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <iostream>
+
+#include "arrow/util/string_header.h"
+
+namespace arrow {
+
+std::ostream& operator<<(std::ostream& os, const StringHeader& header) {
+  os.write(header.data(), header.size());
+  return os;
+}
+
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/string_header.h b/cpp/src/arrow/util/string_header.h
new file mode 100644
index 00000000000..9341bcbc062
--- /dev/null
+++ b/cpp/src/arrow/util/string_header.h
@@ -0,0 +1,377 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <array>
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
+#include <string>
+#include <string_view>
+
+namespace arrow {
+
+/// Variable length string or binary with 4 byte prefix and inline optimization
+/// for small values (12 bytes or fewer). This is similar to std::string_view
+/// except that the referenced is limited in size to UINT32_MAX and up to the
+/// first four bytes of the string are copied into the struct. The prefix allows
+/// failing comparisons early and can reduce the CPU cache working set when
+/// dealing with short strings.
+///
+/// This structure supports three states:
+///
+/// Short string   |----|----|--------|
+///                 ^    ^      ^
+///                 |    |      |
+///                 size prefix remaining in-line portion, zero padded
+///
+/// Long string    |----|----|--------|
+///                 ^    ^      ^
+///                 |    |      |
+///                 size prefix raw pointer to out-of-line portion
+///
+/// IO Long string |----|----|----|----|
+///                 ^    ^      ^     ^
+///                 |    |      |     `----------.
+///                 size prefix buffer index and offset to out-of-line portion
+///
+/// Adapted from TU Munich's UmbraDB [1], Velox, DuckDB.
+///
+/// [1]: https://db.in.tum.de/~freitag/papers/p29-neumann-cidr20.pdf
+///
+/// There is no way to determine from a non-inline StringHeader whether it refers
+/// to its out-of-line portion with a raw pointer or with index/offset. This
+/// information is stored at the column level; so a buffer of StringHeader will
+/// contain only one or the other. In general unless a StringHeader is resident
+/// in a StringView array's buffer it will refer to out-of-line data with a raw
+/// pointer. This default is assumed by several members of StringHeader such as
+/// operator==() and operator string_view() since these and other operations cannot
+/// be performed on index/offset StringHeaders without also accessing the buffers
+/// storing their out-of-line data. Which states pertain to each accessor and
+/// constructor are listed in their comments.
+struct alignas(8) StringHeader {
+ public:
+  using value_type = char;
+
+  static constexpr size_t kTotalSize = 16;
+  static constexpr size_t kSizeSize = sizeof(uint32_t);
+  static constexpr size_t kIndexOffsetSize = sizeof(uint32_t) * 2;
+  static constexpr size_t kPrefixSize = kTotalSize - kSizeSize - kIndexOffsetSize;
+  static_assert(kPrefixSize == 4);
+  static constexpr size_t kInlineSize = kTotalSize - kPrefixSize;
+  static_assert(kInlineSize == 12);
+
+  /// Construct an empty view.
+  StringHeader() = default;
+
+  /// Construct a RAW POINTER view.
+  StringHeader(const char* data, size_t len) : size_(static_cast<uint32_t>(len)) {
+    if (size_ == 0) return;
+
+    // TODO(bkietz) better option than assert?
+    assert(data);
+    if (IsInline()) {
+      // small string: inlined. Bytes beyond size_ are already 0
+      memcpy(prefix_.data(), data, size_);
+    } else {
+      // large string: store pointer
+      memcpy(prefix_.data(), data, kPrefixSize);
+      value_.data = data;
+    }
+  }
+
+  /// Construct a RAW POINTER view.
+  StringHeader(const uint8_t* data, int64_t len)
+      : StringHeader(reinterpret_cast<const char*>(data), static_cast<size_t>(len)) {}
+
+  /// Convenience implicit constructor for RAW POINTER views from C string/string literal.
+  ///
+  /// NOLINTNEXTLINE runtime/explicit
+  StringHeader(const char* data) : StringHeader(data, std::strlen(data)) {}
+
+  /// Construct a RAW POINTER view.
+  explicit StringHeader(const std::string& value)
+      : StringHeader(value.data(), value.size()) {}
+
+  /// Construct a RAW POINTER view.
+  explicit StringHeader(std::string_view value)
+      : StringHeader(value.data(), value.size()) {}
+
+  /// Construct an INDEX/OFFSET view.
+  StringHeader(const char* data, uint32_t len, uint32_t buffer_index,
+               const char* buffer_data)
+      : size_(len) {
+    if (size_ == 0) return;
+
+    // TODO(bkietz) better option than assert?
+    assert(data);
+    if (IsInline()) {
+      // small string: inlined. Bytes beyond size_ are already 0
+      memcpy(prefix_.data(), data, size_);
+    } else {
+      // large string: store index/offset
+      memcpy(prefix_.data(), data, kPrefixSize);
+      SetIndexOffset(buffer_index, static_cast<uint32_t>(data - buffer_data));
+    }
+  }
+
+  /// Construct an INDEX/OFFSET view.
+  StringHeader(uint32_t len, std::array<char, kPrefixSize> prefix, uint32_t buffer_index,
+               uint32_t offset)
+      : size_(len), prefix_(prefix) {
+    SetIndexOffset(buffer_index, offset);
+  }
+
+  template <typename I>
+  static constexpr bool IsInline(I size) {
+    return size <= static_cast<I>(kInlineSize);
+  }
+  static constexpr bool IsInline(uint32_t size) { return size <= kInlineSize; }
+
+  /// True if the view's data is entirely stored inline.
+  /// This function is safe for use against both RAW POINTER and INDEX/OFFSET views.
+  bool IsInline() const { return IsInline(size_); }
+
+  /// Return a RAW POINTER view's data.
+  const char* data() const& { return IsInline() ? prefix_.data() : value_.data; }
+  const char* data() && = delete;
+
+  /// The number of characters viewed by this StringHeader.
+  /// This function is safe for use against both RAW POINTER and INDEX/OFFSET views.
+  size_t size() const { return size_; }
+
+  /// Print a RAW POINTER view to a std::ostream.
+  friend std::ostream& operator<<(std::ostream& os, const StringHeader& header);
+
+  /// Equality comparison between RAW POINTER views.
+  bool operator==(const StringHeader& other) const {
+    // Compare lengths and first 4 characters.
+    if (SizeAndPrefixAsInt64() != other.SizeAndPrefixAsInt64()) {
+      return false;
+    }
+    if (IsInline()) {
+      // The inline part is zeroed at construction, so we can compare
+      // a word at a time if data extends past 'prefix_'.
+      return size_ <= kPrefixSize || InlinedAsInt64() == other.InlinedAsInt64();
+    }
+    // Sizes are equal and this is not inline, therefore both are out
+    // of line and have kPrefixSize first in common.
+    return memcmp(value_.data + kPrefixSize, other.value_.data + kPrefixSize,
+                  size_ - kPrefixSize) == 0;
+  }
+
+  /// Inequality comparison between RAW POINTER views.
+  bool operator!=(const StringHeader& other) const { return !(*this == other); }
+
+  /// Less-than comparison between RAW POINTER views.
+  bool operator<(const StringHeader& other) const { return Compare(other) < 0; }
+
+  /// Less-than-or-equal comparison between RAW POINTER views.
+  bool operator<=(const StringHeader& other) const { return Compare(other) <= 0; }
+
+  /// Greater-than comparison between RAW POINTER views.
+  bool operator>(const StringHeader& other) const { return Compare(other) > 0; }
+
+  /// Greater-than-or-equal comparison between RAW POINTER views.
+  bool operator>=(const StringHeader& other) const { return Compare(other) >= 0; }
+
+  /// Conversion to std::string_view for RAW POINTER views.
+  explicit operator std::string_view() const& { return {data(), size()}; }
+  explicit operator std::string_view() && = delete;
+
+  /// Return the always-inline cached first 4 bytes of this StringHeader.
+  /// This function is safe for use against both RAW POINTER and INDEX/OFFSET views.
+  std::array<char, kPrefixSize> GetPrefix() const { return prefix_; }
+
+  /// Return an INDEX/OFFSET view's buffer index.
+  uint32_t GetBufferIndex() const { return value_.io_data.buffer_index; }
+
+  /// Return an INDEX/OFFSET view's buffer offset.
+  uint32_t GetBufferOffset() const { return value_.io_data.offset; }
+
+  /// Return a RAW POINTER view's data pointer.
+  ///
+  /// NOT VALID FOR INLINE VIEWS.
+  const char* GetRawPointer() const { return value_.data; }
+
+  /// Return an INDEX/OFFSET view's data pointer.
+  ///
+  /// NOT VALID FOR INLINE VIEWS.
+  template <typename BufferPtr>
+  const char* GetPointerFromBuffers(const BufferPtr* char_buffers) const {
+    return char_buffers[GetBufferIndex()]->template data_as<char>() + GetBufferOffset();
+  }
+
+  /// Return an INDEX/OFFSET view's data pointer.
+  template <typename BufferPtr>
+  const char* GetPointerFromBuffersOrInlineData(const BufferPtr* char_buffers) const {
+    return IsInline() ? GetInlineData() : GetPointerFromBuffers(char_buffers);
+  }
+
+  /// Return a the inline data of a view.
+  ///
+  /// For inline views, this points to the entire data of the view.
+  /// For other views, this points to the 4 byte prefix.
+  const char* GetInlineData() const& { return prefix_.data(); }
+  const char* GetInlineData() && = delete;
+
+  /// Mutate into a RAW POINTER view.
+  ///
+  /// This function is only intended for use in converting from an equivalent INDEX/OFFSET
+  /// view; in particular it does not check or modify the prefix for consistency with the
+  /// new data pointer.
+  void SetRawPointer(const char* data) { value_.data = data; }
+
+  /// Mutate into an INDEX/OFFSET view.
+  ///
+  /// This function is only intended for use in converting from an equivalent RAW POINTER
+  /// view; in particular it does not check or modify the prefix for consistency with the
+  /// new buffer index/offset.
+  void SetIndexOffset(uint32_t buffer_index, uint32_t offset) {
+    value_.io_data = {buffer_index, offset};
+  }
+
+  /// Equality compare an INDEX/OFFSET view in place.
+  ///
+  /// Equivalent comparison will be accomplished by (for example) first converting both
+  /// views to std::string_view and comparing those, but this would not take advantage
+  /// of the cached 4 byte prefix.
+  template <typename BufferPtr>
+  bool EqualsIndexOffset(const BufferPtr* char_buffers, const StringHeader& other,
+                         const BufferPtr* other_char_buffers) const {
+    if (SizeAndPrefixAsInt64() != other.SizeAndPrefixAsInt64()) {
+      return false;
+    }
+    if (IsInline()) {
+      return InlinedAsInt64() == other.InlinedAsInt64();
+    }
+    // Sizes are equal and this is not inline, therefore both are out of line and we
+    // have already checked that their kPrefixSize first characters are equal.
+    return memcmp(GetPointerFromBuffers(char_buffers) + kPrefixSize,
+                  other.GetPointerFromBuffers(other_char_buffers) + kPrefixSize,
+                  size() - kPrefixSize) == 0;
+  }
+
+  /// Less-than compare an INDEX/OFFSET view in place.
+  ///
+  /// Equivalent comparison will be accomplished by (for example) first converting both
+  /// views to std::string_view and comparing those, but this would not take advantage
+  /// of the cached 4 byte prefix.
+  template <typename BufferPtr>
+  bool LessThanIndexOffset(const BufferPtr* char_buffers, const StringHeader& other,
+                           const BufferPtr* other_char_buffers) const {
+    return CompareIndexOffset(char_buffers, other, other_char_buffers) < 0;
+  }
+
+ private:
+  // Returns 0, if this == other
+  //       < 0, if this < other
+  //       > 0, if this > other
+  int32_t Compare(const StringHeader& other) const {
+    if (PrefixAsInt() != other.PrefixAsInt()) {
+      // The result is decided on prefix. The shorter will be less
+      // because the prefix is padded with zeros.
+      return memcmp(prefix_.data(), other.prefix_.data(), kPrefixSize);
+    }
+    int32_t size = std::min(size_, other.size_) - kPrefixSize;
+    if (size <= 0) {
+      // One string is just the prefix.
+      return size_ - other.size_;
+    }
+    if (static_cast<uint32_t>(size) <= kInlineSize && IsInline() && other.IsInline()) {
+      int32_t result = memcmp(value_.inlined.data(), other.value_.inlined.data(), size);
+      return (result != 0) ? result : size_ - other.size_;
+    }
+    int32_t result = memcmp(data() + kPrefixSize, other.data() + kPrefixSize, size);
+    return (result != 0) ? result : size_ - other.size_;
+  }
+
+  template <typename BufferPtr>
+  int CompareIndexOffset(const BufferPtr* char_buffers, const StringHeader& other,
+                         const BufferPtr* other_char_buffers) const {
+    if (PrefixAsInt() != other.PrefixAsInt()) {
+      // The result is decided on prefix. The shorter will be less
+      // because the prefix is padded with zeros.
+      return memcmp(prefix_.data(), other.prefix_.data(), kPrefixSize);
+    }
+    int32_t size = std::min(size_, other.size_) - kPrefixSize;
+    if (size <= 0) {
+      // One string is just the prefix.
+      return size_ - other.size_;
+    }
+    if (static_cast<uint32_t>(size) <= kInlineSize && IsInline() && other.IsInline()) {
+      int32_t result = memcmp(value_.inlined.data(), other.value_.inlined.data(), size);
+      return (result != 0) ? result : size_ - other.size_;
+    }
+
+    int32_t result = memcmp(
+        GetPointerFromBuffersOrInlineData(char_buffers) + kPrefixSize,
+        other.GetPointerFromBuffersOrInlineData(other_char_buffers) + kPrefixSize, size);
+    return (result != 0) ? result : size_ - other.size_;
+  }
+
+  int64_t SizeAndPrefixAsInt64() const {
+    return reinterpret_cast<const int64_t*>(this)[0];
+  }
+
+  int64_t InlinedAsInt64() const { return reinterpret_cast<const int64_t*>(this)[1]; }
+
+  int32_t PrefixAsInt() const { return *reinterpret_cast<const int32_t*>(&prefix_); }
+
+  // FIXME(bkietz) replace this with a std::array<uint8_t, 16> and forgo the union.
+  // Type punning (AKA violation of the strict aliasing rule) is undefined behavior.
+  // Using memcpy to access the bytes of the object representation of trivially copyable
+  // objects is not undefined behavior. Given sufficiently explicit hints on alignment
+  // and size, compilers elide memcpy calls in favor of identical assembly to what
+  // the type punning implementation produces.
+  // We rely on all members being laid out top to bottom . C++
+  // guarantees this.
+  uint32_t size_ = 0;
+  std::array<char, kPrefixSize> prefix_ = {0};
+  union {
+    std::array<char, 8> inlined = {0};
+    const char* data;
+    struct {
+      uint32_t buffer_index;
+      uint32_t offset;
+    } io_data;
+  } value_;
+};
+
+static_assert(sizeof(StringHeader) == 16, "struct size expected to be exactly 16 bytes");
+static_assert(alignof(StringHeader) == 8,
+              "struct alignment expected to be exactly 8 bytes");
+
+}  // namespace arrow
diff --git a/cpp/src/arrow/visit_data_inline.h b/cpp/src/arrow/visit_data_inline.h
index 6a9b32d73a6..a6793210a89 100644
--- a/cpp/src/arrow/visit_data_inline.h
+++ b/cpp/src/arrow/visit_data_inline.h
@@ -144,6 +144,67 @@ struct ArraySpanInlineVisitor<T, enable_if_base_binary<T>> {
   }
 };
 
+// BinaryView, StringView...
+template <typename T>
+struct ArraySpanInlineVisitor<T, enable_if_binary_view_like<T>> {
+  using c_type = std::string_view;
+
+  static std::string_view GetView(const StringHeader& s,
+                                  const std::shared_ptr<Buffer>* char_buffers) {
+    if (!s.IsInline()) {
+      const auto& buffer = char_buffers[s.GetBufferIndex()];
+      return std::string_view{buffer->data_as<char>() + s.GetBufferOffset(), s.size()};
+    }
+    return std::string_view{s.GetInlineData(), s.size()};
+  }
+
+  static const std::shared_ptr<Buffer>* GetCharBuffers(const ArraySpan& arr) {
+    return reinterpret_cast<const std::shared_ptr<Buffer>*>(arr.buffers[2].data);
+  }
+
+  template <typename ValidFunc, typename NullFunc>
+  static Status VisitStatus(const ArraySpan& arr, ValidFunc&& valid_func,
+                            NullFunc&& null_func) {
+    if (arr.length == 0) {
+      return Status::OK();
+    }
+    auto* s = arr.GetValues<StringHeader>(1);
+    if (checked_cast<const BinaryViewType*>(arr.type)->has_raw_pointers()) {
+      return VisitBitBlocks(
+          arr.buffers[0].data, arr.offset, arr.length,
+          [&](int64_t index) { return valid_func(std::string_view{s[index]}); },
+          [&]() { return null_func(); });
+    } else {
+      auto* char_buffers = GetCharBuffers(arr);
+      return VisitBitBlocks(
+          arr.buffers[0].data, arr.offset, arr.length,
+          [&](int64_t index) { return valid_func(GetView(s[index], char_buffers)); },
+          [&]() { return null_func(); });
+    }
+  }
+
+  template <typename ValidFunc, typename NullFunc>
+  static void VisitVoid(const ArraySpan& arr, ValidFunc&& valid_func,
+                        NullFunc&& null_func) {
+    if (arr.length == 0) {
+      return;
+    }
+    auto* s = arr.GetValues<StringHeader>(1);
+    if (checked_cast<const BinaryViewType*>(arr.type)->has_raw_pointers()) {
+      VisitBitBlocksVoid(
+          arr.buffers[0].data, arr.offset, arr.length,
+          [&](int64_t index) { valid_func(std::string_view{s[index]}); },
+          std::forward<NullFunc>(null_func));
+    } else {
+      auto* char_buffers = GetCharBuffers(arr);
+      VisitBitBlocksVoid(
+          arr.buffers[0].data, arr.offset, arr.length,
+          [&](int64_t index) { valid_func(GetView(s[index], char_buffers)); },
+          std::forward<NullFunc>(null_func));
+    }
+  }
+};
+
 // FixedSizeBinary, Decimal128
 template <typename T>
 struct ArraySpanInlineVisitor<T, enable_if_fixed_size_binary<T>> {
@@ -273,9 +334,8 @@ typename internal::call_traits::enable_if_return<ValidFunc, void>::type
 VisitNullBitmapInline(const uint8_t* valid_bits, int64_t valid_bits_offset,
                       int64_t num_values, int64_t null_count, ValidFunc&& valid_func,
                       NullFunc&& null_func) {
-  ARROW_UNUSED(null_count);
-  internal::OptionalBitBlockCounter bit_counter(valid_bits, valid_bits_offset,
-                                                num_values);
+  internal::OptionalBitBlockCounter bit_counter(null_count == 0 ? NULLPTR : valid_bits,
+                                                valid_bits_offset, num_values);
   int64_t position = 0;
   int64_t offset_position = valid_bits_offset;
   while (position < num_values) {
diff --git a/cpp/src/arrow/visitor.cc b/cpp/src/arrow/visitor.cc
index ed3d5bc2c68..e057f6b12fb 100644
--- a/cpp/src/arrow/visitor.cc
+++ b/cpp/src/arrow/visitor.cc
@@ -45,8 +45,10 @@ ARRAY_VISITOR_DEFAULT(UInt64Array)
 ARRAY_VISITOR_DEFAULT(HalfFloatArray)
 ARRAY_VISITOR_DEFAULT(FloatArray)
 ARRAY_VISITOR_DEFAULT(DoubleArray)
-ARRAY_VISITOR_DEFAULT(BinaryArray)
 ARRAY_VISITOR_DEFAULT(StringArray)
+ARRAY_VISITOR_DEFAULT(StringViewArray)
+ARRAY_VISITOR_DEFAULT(BinaryArray)
+ARRAY_VISITOR_DEFAULT(BinaryViewArray)
 ARRAY_VISITOR_DEFAULT(LargeBinaryArray)
 ARRAY_VISITOR_DEFAULT(LargeStringArray)
 ARRAY_VISITOR_DEFAULT(FixedSizeBinaryArray)
@@ -96,7 +98,9 @@ TYPE_VISITOR_DEFAULT(HalfFloatType)
 TYPE_VISITOR_DEFAULT(FloatType)
 TYPE_VISITOR_DEFAULT(DoubleType)
 TYPE_VISITOR_DEFAULT(StringType)
+TYPE_VISITOR_DEFAULT(StringViewType)
 TYPE_VISITOR_DEFAULT(BinaryType)
+TYPE_VISITOR_DEFAULT(BinaryViewType)
 TYPE_VISITOR_DEFAULT(LargeStringType)
 TYPE_VISITOR_DEFAULT(LargeBinaryType)
 TYPE_VISITOR_DEFAULT(FixedSizeBinaryType)
@@ -147,7 +151,9 @@ SCALAR_VISITOR_DEFAULT(HalfFloatScalar)
 SCALAR_VISITOR_DEFAULT(FloatScalar)
 SCALAR_VISITOR_DEFAULT(DoubleScalar)
 SCALAR_VISITOR_DEFAULT(StringScalar)
+SCALAR_VISITOR_DEFAULT(StringViewScalar)
 SCALAR_VISITOR_DEFAULT(BinaryScalar)
+SCALAR_VISITOR_DEFAULT(BinaryViewScalar)
 SCALAR_VISITOR_DEFAULT(LargeStringScalar)
 SCALAR_VISITOR_DEFAULT(LargeBinaryScalar)
 SCALAR_VISITOR_DEFAULT(FixedSizeBinaryScalar)
diff --git a/cpp/src/arrow/visitor.h b/cpp/src/arrow/visitor.h
index b22d4d3c567..650b0e7ee0a 100644
--- a/cpp/src/arrow/visitor.h
+++ b/cpp/src/arrow/visitor.h
@@ -45,7 +45,9 @@ class ARROW_EXPORT ArrayVisitor {
   virtual Status Visit(const FloatArray& array);
   virtual Status Visit(const DoubleArray& array);
   virtual Status Visit(const StringArray& array);
+  virtual Status Visit(const StringViewArray& array);
   virtual Status Visit(const BinaryArray& array);
+  virtual Status Visit(const BinaryViewArray& array);
   virtual Status Visit(const LargeStringArray& array);
   virtual Status Visit(const LargeBinaryArray& array);
   virtual Status Visit(const FixedSizeBinaryArray& array);
@@ -94,7 +96,9 @@ class ARROW_EXPORT TypeVisitor {
   virtual Status Visit(const FloatType& type);
   virtual Status Visit(const DoubleType& type);
   virtual Status Visit(const StringType& type);
+  virtual Status Visit(const StringViewType& type);
   virtual Status Visit(const BinaryType& type);
+  virtual Status Visit(const BinaryViewType& type);
   virtual Status Visit(const LargeStringType& type);
   virtual Status Visit(const LargeBinaryType& type);
   virtual Status Visit(const FixedSizeBinaryType& type);
@@ -143,7 +147,9 @@ class ARROW_EXPORT ScalarVisitor {
   virtual Status Visit(const FloatScalar& scalar);
   virtual Status Visit(const DoubleScalar& scalar);
   virtual Status Visit(const StringScalar& scalar);
+  virtual Status Visit(const StringViewScalar& scalar);
   virtual Status Visit(const BinaryScalar& scalar);
+  virtual Status Visit(const BinaryViewScalar& scalar);
   virtual Status Visit(const LargeStringScalar& scalar);
   virtual Status Visit(const LargeBinaryScalar& scalar);
   virtual Status Visit(const FixedSizeBinaryScalar& scalar);
diff --git a/cpp/src/arrow/visitor_generate.h b/cpp/src/arrow/visitor_generate.h
index 8f6b176ba8f..4b57abe53ff 100644
--- a/cpp/src/arrow/visitor_generate.h
+++ b/cpp/src/arrow/visitor_generate.h
@@ -40,7 +40,9 @@ namespace arrow {
   ACTION(Boolean);                              \
   ARROW_GENERATE_FOR_ALL_NUMERIC_TYPES(ACTION); \
   ACTION(String);                               \
+  ACTION(StringView);                           \
   ACTION(Binary);                               \
+  ACTION(BinaryView);                           \
   ACTION(LargeString);                          \
   ACTION(LargeBinary);                          \
   ACTION(FixedSizeBinary);                      \
diff --git a/cpp/src/gandiva/gdv_hash_function_stubs.cc b/cpp/src/gandiva/gdv_hash_function_stubs.cc
index 018b0fbb709..710b3ffb757 100644
--- a/cpp/src/gandiva/gdv_hash_function_stubs.cc
+++ b/cpp/src/gandiva/gdv_hash_function_stubs.cc
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//#pragma once
+// #pragma once
 
 #include "gandiva/engine.h"
 #include "gandiva/exported_funcs.h"
diff --git a/cpp/src/gandiva/gdv_string_function_stubs.cc b/cpp/src/gandiva/gdv_string_function_stubs.cc
index cf04de3a8e1..069b972f9e6 100644
--- a/cpp/src/gandiva/gdv_string_function_stubs.cc
+++ b/cpp/src/gandiva/gdv_string_function_stubs.cc
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//#pragma once
+// #pragma once
 
 #include "gandiva/gdv_function_stubs.h"
 
diff --git a/cpp/src/gandiva/precompiled/string_ops_test.cc b/cpp/src/gandiva/precompiled/string_ops_test.cc
index b84c51b3a6b..82c62c8851d 100644
--- a/cpp/src/gandiva/precompiled/string_ops_test.cc
+++ b/cpp/src/gandiva/precompiled/string_ops_test.cc
@@ -101,15 +101,15 @@ TEST(TestStringOps, TestChrBigInt) {
   out = chr_int64(ctx_ptr, -66, &out_len);
   EXPECT_EQ(std::string(out, out_len), "\xBE");
 
-  //€
+  // €
   out = chr_int32(ctx_ptr, 128, &out_len);
   EXPECT_EQ(std::string(out, out_len), "\x80");
 
-  //œ
+  // œ
   out = chr_int64(ctx_ptr, 156, &out_len);
   EXPECT_EQ(std::string(out, out_len), "\x9C");
 
-  //ÿ
+  // ÿ
   out = chr_int32(ctx_ptr, 255, &out_len);
   EXPECT_EQ(std::string(out, out_len), "\xFF");
 
diff --git a/cpp/src/generated/File_generated.h b/cpp/src/generated/File_generated.h
index 5b219f1eb0e..06953c4a040 100644
--- a/cpp/src/generated/File_generated.h
+++ b/cpp/src/generated/File_generated.h
@@ -26,18 +26,15 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Block FLATBUFFERS_FINAL_CLASS {
   int64_t bodyLength_;
 
  public:
-  Block()
-      : offset_(0),
-        metaDataLength_(0),
-        padding0__(0),
-        bodyLength_(0) {
-    (void)padding0__;
+  Block() {
+    memset(static_cast<void *>(this), 0, sizeof(Block));
   }
   Block(int64_t _offset, int32_t _metaDataLength, int64_t _bodyLength)
       : offset_(flatbuffers::EndianScalar(_offset)),
         metaDataLength_(flatbuffers::EndianScalar(_metaDataLength)),
         padding0__(0),
         bodyLength_(flatbuffers::EndianScalar(_bodyLength)) {
+    (void)padding0__;
   }
   /// Index to the start of the RecordBlock (note this is past the Message header)
   int64_t offset() const {
@@ -122,6 +119,7 @@ struct FooterBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FooterBuilder &operator=(const FooterBuilder &);
   flatbuffers::Offset<Footer> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Footer>(end);
diff --git a/cpp/src/generated/Message_generated.h b/cpp/src/generated/Message_generated.h
index d0c71e04294..3af66820765 100644
--- a/cpp/src/generated/Message_generated.h
+++ b/cpp/src/generated/Message_generated.h
@@ -188,9 +188,8 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) FieldNode FLATBUFFERS_FINAL_CLASS {
   int64_t null_count_;
 
  public:
-  FieldNode()
-      : length_(0),
-        null_count_(0) {
+  FieldNode() {
+    memset(static_cast<void *>(this), 0, sizeof(FieldNode));
   }
   FieldNode(int64_t _length, int64_t _null_count)
       : length_(flatbuffers::EndianScalar(_length)),
@@ -250,6 +249,7 @@ struct BodyCompressionBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  BodyCompressionBuilder &operator=(const BodyCompressionBuilder &);
   flatbuffers::Offset<BodyCompression> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<BodyCompression>(end);
@@ -276,7 +276,8 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_LENGTH = 4,
     VT_NODES = 6,
     VT_BUFFERS = 8,
-    VT_COMPRESSION = 10
+    VT_COMPRESSION = 10,
+    VT_VARIADICCOUNTS = 12
   };
   /// number of records / rows. The arrays in the batch should all have this
   /// length
@@ -300,6 +301,13 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::BodyCompression *compression() const {
     return GetPointer<const org::apache::arrow::flatbuf::BodyCompression *>(VT_COMPRESSION);
   }
+  /// Some types such as Utf8View are represented using a variable number of buffers.
+  /// For each such Field in the pre-ordered flattened logical schema, there will be
+  /// an entry in variadicCounts to indicate the number of extra buffers which belong
+  /// to that Field.
+  const flatbuffers::Vector<int64_t> *variadicCounts() const {
+    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_VARIADICCOUNTS);
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int64_t>(verifier, VT_LENGTH) &&
@@ -309,6 +317,8 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            verifier.VerifyVector(buffers()) &&
            VerifyOffset(verifier, VT_COMPRESSION) &&
            verifier.VerifyTable(compression()) &&
+           VerifyOffset(verifier, VT_VARIADICCOUNTS) &&
+           verifier.VerifyVector(variadicCounts()) &&
            verifier.EndTable();
   }
 };
@@ -329,10 +339,14 @@ struct RecordBatchBuilder {
   void add_compression(flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression) {
     fbb_.AddOffset(RecordBatch::VT_COMPRESSION, compression);
   }
+  void add_variadicCounts(flatbuffers::Offset<flatbuffers::Vector<int64_t>> variadicCounts) {
+    fbb_.AddOffset(RecordBatch::VT_VARIADICCOUNTS, variadicCounts);
+  }
   explicit RecordBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  RecordBatchBuilder &operator=(const RecordBatchBuilder &);
   flatbuffers::Offset<RecordBatch> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<RecordBatch>(end);
@@ -345,9 +359,11 @@ inline flatbuffers::Offset<RecordBatch> CreateRecordBatch(
     int64_t length = 0,
     flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes = 0,
     flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers = 0,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0) {
+    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0,
+    flatbuffers::Offset<flatbuffers::Vector<int64_t>> variadicCounts = 0) {
   RecordBatchBuilder builder_(_fbb);
   builder_.add_length(length);
+  builder_.add_variadicCounts(variadicCounts);
   builder_.add_compression(compression);
   builder_.add_buffers(buffers);
   builder_.add_nodes(nodes);
@@ -359,15 +375,18 @@ inline flatbuffers::Offset<RecordBatch> CreateRecordBatchDirect(
     int64_t length = 0,
     const std::vector<org::apache::arrow::flatbuf::FieldNode> *nodes = nullptr,
     const std::vector<org::apache::arrow::flatbuf::Buffer> *buffers = nullptr,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0) {
+    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0,
+    const std::vector<int64_t> *variadicCounts = nullptr) {
   auto nodes__ = nodes ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::FieldNode>(*nodes) : 0;
   auto buffers__ = buffers ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::Buffer>(*buffers) : 0;
+  auto variadicCounts__ = variadicCounts ? _fbb.CreateVector<int64_t>(*variadicCounts) : 0;
   return org::apache::arrow::flatbuf::CreateRecordBatch(
       _fbb,
       length,
       nodes__,
       buffers__,
-      compression);
+      compression,
+      variadicCounts__);
 }
 
 /// For sending dictionary encoding information. Any Field can be
@@ -422,6 +441,7 @@ struct DictionaryBatchBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DictionaryBatchBuilder &operator=(const DictionaryBatchBuilder &);
   flatbuffers::Offset<DictionaryBatch> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<DictionaryBatch>(end);
@@ -538,6 +558,7 @@ struct MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  MessageBuilder &operator=(const MessageBuilder &);
   flatbuffers::Offset<Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Message>(end);
diff --git a/cpp/src/generated/Schema_generated.h b/cpp/src/generated/Schema_generated.h
index 89204c894aa..61c14f66921 100644
--- a/cpp/src/generated/Schema_generated.h
+++ b/cpp/src/generated/Schema_generated.h
@@ -50,6 +50,12 @@ struct LargeUtf8Builder;
 struct LargeBinary;
 struct LargeBinaryBuilder;
 
+struct Utf8View;
+struct Utf8ViewBuilder;
+
+struct BinaryView;
+struct BinaryViewBuilder;
+
 struct FixedSizeBinary;
 struct FixedSizeBinaryBuilder;
 
@@ -386,11 +392,13 @@ enum class Type : uint8_t {
   LargeUtf8 = 20,
   LargeList = 21,
   RunEndEncoded = 22,
+  BinaryView = 23,
+  Utf8View = 24,
   MIN = NONE,
-  MAX = RunEndEncoded
+  MAX = Utf8View
 };
 
-inline const Type (&EnumValuesType())[23] {
+inline const Type (&EnumValuesType())[25] {
   static const Type values[] = {
     Type::NONE,
     Type::Null,
@@ -414,13 +422,15 @@ inline const Type (&EnumValuesType())[23] {
     Type::LargeBinary,
     Type::LargeUtf8,
     Type::LargeList,
-    Type::RunEndEncoded
+    Type::RunEndEncoded,
+    Type::BinaryView,
+    Type::Utf8View
   };
   return values;
 }
 
 inline const char * const *EnumNamesType() {
-  static const char * const names[24] = {
+  static const char * const names[26] = {
     "NONE",
     "Null",
     "Int",
@@ -444,13 +454,15 @@ inline const char * const *EnumNamesType() {
     "LargeUtf8",
     "LargeList",
     "RunEndEncoded",
+    "BinaryView",
+    "Utf8View",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameType(Type e) {
-  if (flatbuffers::IsOutRange(e, Type::NONE, Type::RunEndEncoded)) return "";
+  if (flatbuffers::IsOutRange(e, Type::NONE, Type::Utf8View)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesType()[index];
 }
@@ -547,6 +559,14 @@ template<> struct TypeTraits<org::apache::arrow::flatbuf::RunEndEncoded> {
   static const Type enum_value = Type::RunEndEncoded;
 };
 
+template<> struct TypeTraits<org::apache::arrow::flatbuf::BinaryView> {
+  static const Type enum_value = Type::BinaryView;
+};
+
+template<> struct TypeTraits<org::apache::arrow::flatbuf::Utf8View> {
+  static const Type enum_value = Type::Utf8View;
+};
+
 bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type type);
 bool VerifyTypeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
 
@@ -622,9 +642,8 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Buffer FLATBUFFERS_FINAL_CLASS {
   int64_t length_;
 
  public:
-  Buffer()
-      : offset_(0),
-        length_(0) {
+  Buffer() {
+    memset(static_cast<void *>(this), 0, sizeof(Buffer));
   }
   Buffer(int64_t _offset, int64_t _length)
       : offset_(flatbuffers::EndianScalar(_offset)),
@@ -663,6 +682,7 @@ struct NullBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  NullBuilder &operator=(const NullBuilder &);
   flatbuffers::Offset<Null> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Null>(end);
@@ -695,6 +715,7 @@ struct Struct_Builder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Struct_Builder &operator=(const Struct_Builder &);
   flatbuffers::Offset<Struct_> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Struct_>(end);
@@ -724,6 +745,7 @@ struct ListBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  ListBuilder &operator=(const ListBuilder &);
   flatbuffers::Offset<List> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<List>(end);
@@ -755,6 +777,7 @@ struct LargeListBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  LargeListBuilder &operator=(const LargeListBuilder &);
   flatbuffers::Offset<LargeList> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LargeList>(end);
@@ -795,6 +818,7 @@ struct FixedSizeListBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FixedSizeListBuilder &operator=(const FixedSizeListBuilder &);
   flatbuffers::Offset<FixedSizeList> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<FixedSizeList>(end);
@@ -862,6 +886,7 @@ struct MapBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  MapBuilder &operator=(const MapBuilder &);
   flatbuffers::Offset<Map> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Map>(end);
@@ -916,6 +941,7 @@ struct UnionBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  UnionBuilder &operator=(const UnionBuilder &);
   flatbuffers::Offset<Union> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Union>(end);
@@ -978,6 +1004,7 @@ struct IntBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  IntBuilder &operator=(const IntBuilder &);
   flatbuffers::Offset<Int> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Int>(end);
@@ -1021,6 +1048,7 @@ struct FloatingPointBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FloatingPointBuilder &operator=(const FloatingPointBuilder &);
   flatbuffers::Offset<FloatingPoint> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<FloatingPoint>(end);
@@ -1053,6 +1081,7 @@ struct Utf8Builder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Utf8Builder &operator=(const Utf8Builder &);
   flatbuffers::Offset<Utf8> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Utf8>(end);
@@ -1083,6 +1112,7 @@ struct BinaryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  BinaryBuilder &operator=(const BinaryBuilder &);
   flatbuffers::Offset<Binary> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Binary>(end);
@@ -1114,6 +1144,7 @@ struct LargeUtf8Builder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  LargeUtf8Builder &operator=(const LargeUtf8Builder &);
   flatbuffers::Offset<LargeUtf8> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LargeUtf8>(end);
@@ -1145,6 +1176,7 @@ struct LargeBinaryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  LargeBinaryBuilder &operator=(const LargeBinaryBuilder &);
   flatbuffers::Offset<LargeBinary> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LargeBinary>(end);
@@ -1158,6 +1190,70 @@ inline flatbuffers::Offset<LargeBinary> CreateLargeBinary(
   return builder_.Finish();
 }
 
+/// Same as Utf8, but string characters are delimited with a packed
+/// length/pointer instead of offsets.
+struct Utf8View FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef Utf8ViewBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct Utf8ViewBuilder {
+  typedef Utf8View Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit Utf8ViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  Utf8ViewBuilder &operator=(const Utf8ViewBuilder &);
+  flatbuffers::Offset<Utf8View> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Utf8View>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Utf8View> CreateUtf8View(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  Utf8ViewBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+/// Same as Binary, but string characters are delimited with a packed
+/// length/pointeBinary of offsets.
+struct BinaryView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef BinaryViewBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct BinaryViewBuilder {
+  typedef BinaryView Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit BinaryViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  BinaryViewBuilder &operator=(const BinaryViewBuilder &);
+  flatbuffers::Offset<BinaryView> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<BinaryView>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<BinaryView> CreateBinaryView(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  BinaryViewBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
 struct FixedSizeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef FixedSizeBinaryBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -1185,6 +1281,7 @@ struct FixedSizeBinaryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FixedSizeBinaryBuilder &operator=(const FixedSizeBinaryBuilder &);
   flatbuffers::Offset<FixedSizeBinary> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<FixedSizeBinary>(end);
@@ -1216,6 +1313,7 @@ struct BoolBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  BoolBuilder &operator=(const BoolBuilder &);
   flatbuffers::Offset<Bool> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Bool>(end);
@@ -1250,6 +1348,7 @@ struct RunEndEncodedBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  RunEndEncodedBuilder &operator=(const RunEndEncodedBuilder &);
   flatbuffers::Offset<RunEndEncoded> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<RunEndEncoded>(end);
@@ -1313,6 +1412,7 @@ struct DecimalBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DecimalBuilder &operator=(const DecimalBuilder &);
   flatbuffers::Offset<Decimal> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Decimal>(end);
@@ -1364,6 +1464,7 @@ struct DateBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DateBuilder &operator=(const DateBuilder &);
   flatbuffers::Offset<Date> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Date>(end);
@@ -1427,6 +1528,7 @@ struct TimeBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TimeBuilder &operator=(const TimeBuilder &);
   flatbuffers::Offset<Time> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Time>(end);
@@ -1594,6 +1696,7 @@ struct TimestampBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TimestampBuilder &operator=(const TimestampBuilder &);
   flatbuffers::Offset<Timestamp> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Timestamp>(end);
@@ -1648,6 +1751,7 @@ struct IntervalBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  IntervalBuilder &operator=(const IntervalBuilder &);
   flatbuffers::Offset<Interval> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Interval>(end);
@@ -1689,6 +1793,7 @@ struct DurationBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DurationBuilder &operator=(const DurationBuilder &);
   flatbuffers::Offset<Duration> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Duration>(end);
@@ -1743,6 +1848,7 @@ struct KeyValueBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  KeyValueBuilder &operator=(const KeyValueBuilder &);
   flatbuffers::Offset<KeyValue> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<KeyValue>(end);
@@ -1835,6 +1941,7 @@ struct DictionaryEncodingBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DictionaryEncodingBuilder &operator=(const DictionaryEncodingBuilder &);
   flatbuffers::Offset<DictionaryEncoding> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<DictionaryEncoding>(end);
@@ -1952,6 +2059,12 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::RunEndEncoded *type_as_RunEndEncoded() const {
     return type_type() == org::apache::arrow::flatbuf::Type::RunEndEncoded ? static_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::BinaryView *type_as_BinaryView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::BinaryView ? static_cast<const org::apache::arrow::flatbuf::BinaryView *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::Utf8View *type_as_Utf8View() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::Utf8View ? static_cast<const org::apache::arrow::flatbuf::Utf8View *>(type()) : nullptr;
+  }
   /// Present only if the field is dictionary encoded.
   const org::apache::arrow::flatbuf::DictionaryEncoding *dictionary() const {
     return GetPointer<const org::apache::arrow::flatbuf::DictionaryEncoding *>(VT_DICTIONARY);
@@ -2073,6 +2186,14 @@ template<> inline const org::apache::arrow::flatbuf::RunEndEncoded *Field::type_
   return type_as_RunEndEncoded();
 }
 
+template<> inline const org::apache::arrow::flatbuf::BinaryView *Field::type_as<org::apache::arrow::flatbuf::BinaryView>() const {
+  return type_as_BinaryView();
+}
+
+template<> inline const org::apache::arrow::flatbuf::Utf8View *Field::type_as<org::apache::arrow::flatbuf::Utf8View>() const {
+  return type_as_Utf8View();
+}
+
 struct FieldBuilder {
   typedef Field Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -2102,6 +2223,7 @@ struct FieldBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FieldBuilder &operator=(const FieldBuilder &);
   flatbuffers::Offset<Field> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Field>(end);
@@ -2213,6 +2335,7 @@ struct SchemaBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SchemaBuilder &operator=(const SchemaBuilder &);
   flatbuffers::Offset<Schema> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Schema>(end);
@@ -2344,6 +2467,14 @@ inline bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type ty
       auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case Type::BinaryView: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::BinaryView *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type::Utf8View: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::Utf8View *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return true;
   }
 }
diff --git a/cpp/src/generated/SparseTensor_generated.h b/cpp/src/generated/SparseTensor_generated.h
index b3fa2dbff46..2de3c7e424d 100644
--- a/cpp/src/generated/SparseTensor_generated.h
+++ b/cpp/src/generated/SparseTensor_generated.h
@@ -204,6 +204,7 @@ struct SparseTensorIndexCOOBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SparseTensorIndexCOOBuilder &operator=(const SparseTensorIndexCOOBuilder &);
   flatbuffers::Offset<SparseTensorIndexCOO> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseTensorIndexCOO>(end);
@@ -338,6 +339,7 @@ struct SparseMatrixIndexCSXBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SparseMatrixIndexCSXBuilder &operator=(const SparseMatrixIndexCSXBuilder &);
   flatbuffers::Offset<SparseMatrixIndexCSX> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseMatrixIndexCSX>(end);
@@ -492,6 +494,7 @@ struct SparseTensorIndexCSFBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SparseTensorIndexCSFBuilder &operator=(const SparseTensorIndexCSFBuilder &);
   flatbuffers::Offset<SparseTensorIndexCSF> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseTensorIndexCSF>(end);
@@ -626,6 +629,12 @@ struct SparseTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::RunEndEncoded *type_as_RunEndEncoded() const {
     return type_type() == org::apache::arrow::flatbuf::Type::RunEndEncoded ? static_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::BinaryView *type_as_BinaryView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::BinaryView ? static_cast<const org::apache::arrow::flatbuf::BinaryView *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::Utf8View *type_as_Utf8View() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::Utf8View ? static_cast<const org::apache::arrow::flatbuf::Utf8View *>(type()) : nullptr;
+  }
   /// The dimensions of the tensor, optionally named.
   const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
@@ -760,6 +769,14 @@ template<> inline const org::apache::arrow::flatbuf::RunEndEncoded *SparseTensor
   return type_as_RunEndEncoded();
 }
 
+template<> inline const org::apache::arrow::flatbuf::BinaryView *SparseTensor::type_as<org::apache::arrow::flatbuf::BinaryView>() const {
+  return type_as_BinaryView();
+}
+
+template<> inline const org::apache::arrow::flatbuf::Utf8View *SparseTensor::type_as<org::apache::arrow::flatbuf::Utf8View>() const {
+  return type_as_Utf8View();
+}
+
 template<> inline const org::apache::arrow::flatbuf::SparseTensorIndexCOO *SparseTensor::sparseIndex_as<org::apache::arrow::flatbuf::SparseTensorIndexCOO>() const {
   return sparseIndex_as_SparseTensorIndexCOO();
 }
@@ -801,6 +818,7 @@ struct SparseTensorBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SparseTensorBuilder &operator=(const SparseTensorBuilder &);
   flatbuffers::Offset<SparseTensor> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseTensor>(end);
diff --git a/cpp/src/generated/Tensor_generated.h b/cpp/src/generated/Tensor_generated.h
index 572b922e20f..5fd36366b23 100644
--- a/cpp/src/generated/Tensor_generated.h
+++ b/cpp/src/generated/Tensor_generated.h
@@ -59,6 +59,7 @@ struct TensorDimBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TensorDimBuilder &operator=(const TensorDimBuilder &);
   flatbuffers::Offset<TensorDim> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TensorDim>(end);
@@ -171,6 +172,12 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::RunEndEncoded *type_as_RunEndEncoded() const {
     return type_type() == org::apache::arrow::flatbuf::Type::RunEndEncoded ? static_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::BinaryView *type_as_BinaryView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::BinaryView ? static_cast<const org::apache::arrow::flatbuf::BinaryView *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::Utf8View *type_as_Utf8View() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::Utf8View ? static_cast<const org::apache::arrow::flatbuf::Utf8View *>(type()) : nullptr;
+  }
   /// The dimensions of the tensor, optionally named
   const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
@@ -287,6 +294,14 @@ template<> inline const org::apache::arrow::flatbuf::RunEndEncoded *Tensor::type
   return type_as_RunEndEncoded();
 }
 
+template<> inline const org::apache::arrow::flatbuf::BinaryView *Tensor::type_as<org::apache::arrow::flatbuf::BinaryView>() const {
+  return type_as_BinaryView();
+}
+
+template<> inline const org::apache::arrow::flatbuf::Utf8View *Tensor::type_as<org::apache::arrow::flatbuf::Utf8View>() const {
+  return type_as_Utf8View();
+}
+
 struct TensorBuilder {
   typedef Tensor Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -310,6 +325,7 @@ struct TensorBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TensorBuilder &operator=(const TensorBuilder &);
   flatbuffers::Offset<Tensor> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Tensor>(end);
diff --git a/cpp/src/generated/feather_generated.h b/cpp/src/generated/feather_generated.h
index 3696188b0f5..b925eb2bc6a 100644
--- a/cpp/src/generated/feather_generated.h
+++ b/cpp/src/generated/feather_generated.h
@@ -324,6 +324,7 @@ struct PrimitiveArrayBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  PrimitiveArrayBuilder &operator=(const PrimitiveArrayBuilder &);
   flatbuffers::Offset<PrimitiveArray> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PrimitiveArray>(end);
@@ -386,6 +387,7 @@ struct CategoryMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  CategoryMetadataBuilder &operator=(const CategoryMetadataBuilder &);
   flatbuffers::Offset<CategoryMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<CategoryMetadata>(end);
@@ -440,6 +442,7 @@ struct TimestampMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TimestampMetadataBuilder &operator=(const TimestampMetadataBuilder &);
   flatbuffers::Offset<TimestampMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TimestampMetadata>(end);
@@ -484,6 +487,7 @@ struct DateMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DateMetadataBuilder &operator=(const DateMetadataBuilder &);
   flatbuffers::Offset<DateMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<DateMetadata>(end);
@@ -523,6 +527,7 @@ struct TimeMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TimeMetadataBuilder &operator=(const TimeMetadataBuilder &);
   flatbuffers::Offset<TimeMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TimeMetadata>(end);
@@ -630,6 +635,7 @@ struct ColumnBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  ColumnBuilder &operator=(const ColumnBuilder &);
   flatbuffers::Offset<Column> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Column>(end);
@@ -739,6 +745,7 @@ struct CTableBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  CTableBuilder &operator=(const CTableBuilder &);
   flatbuffers::Offset<CTable> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<CTable>(end);
diff --git a/cpp/src/parquet/arrow/reader_internal.cc b/cpp/src/parquet/arrow/reader_internal.cc
index a294b712a7c..d88677cec9e 100644
--- a/cpp/src/parquet/arrow/reader_internal.cc
+++ b/cpp/src/parquet/arrow/reader_internal.cc
@@ -768,6 +768,8 @@ Status TransferColumnData(RecordReader* reader, const std::shared_ptr<Field>& va
     case ::arrow::Type::FIXED_SIZE_BINARY:
     case ::arrow::Type::BINARY:
     case ::arrow::Type::STRING:
+    case ::arrow::Type::BINARY_VIEW:
+    case ::arrow::Type::STRING_VIEW:
     case ::arrow::Type::LARGE_BINARY:
     case ::arrow::Type::LARGE_STRING: {
       RETURN_NOT_OK(TransferBinary(reader, pool, value_field, &chunked_result));
diff --git a/cpp/src/parquet/arrow/schema.cc b/cpp/src/parquet/arrow/schema.cc
index c5d5e0743a7..4fae3497e16 100644
--- a/cpp/src/parquet/arrow/schema.cc
+++ b/cpp/src/parquet/arrow/schema.cc
@@ -341,11 +341,13 @@ Status FieldToNode(const std::string& name, const std::shared_ptr<Field>& field,
       break;
     case ArrowTypeId::LARGE_STRING:
     case ArrowTypeId::STRING:
+    case ArrowTypeId::STRING_VIEW:
       type = ParquetType::BYTE_ARRAY;
       logical_type = LogicalType::String();
       break;
     case ArrowTypeId::LARGE_BINARY:
     case ArrowTypeId::BINARY:
+    case ArrowTypeId::BINARY_VIEW:
       type = ParquetType::BYTE_ARRAY;
       break;
     case ArrowTypeId::FIXED_SIZE_BINARY: {
@@ -948,7 +950,11 @@ Result<bool> ApplyOriginalStorageMetadata(const Field& origin_field,
 
   if ((origin_type->id() == ::arrow::Type::LARGE_BINARY &&
        inferred_type->id() == ::arrow::Type::BINARY) ||
+      (origin_type->id() == ::arrow::Type::BINARY_VIEW &&
+       inferred_type->id() == ::arrow::Type::BINARY) ||
       (origin_type->id() == ::arrow::Type::LARGE_STRING &&
+       inferred_type->id() == ::arrow::Type::STRING) ||
+      (origin_type->id() == ::arrow::Type::STRING_VIEW &&
        inferred_type->id() == ::arrow::Type::STRING)) {
     // Read back binary-like arrays with the intended offset width.
     inferred->field = inferred->field->WithType(origin_type);
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index 33e9f8f6658..0a348fd79dc 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -134,6 +134,7 @@ struct ValueBufferSlicer {
   NOT_IMPLEMENTED_VISIT(Dictionary);
   NOT_IMPLEMENTED_VISIT(RunEndEncoded);
   NOT_IMPLEMENTED_VISIT(Extension);
+  NOT_IMPLEMENTED_VISIT(BinaryView);
 
 #undef NOT_IMPLEMENTED_VISIT
 
@@ -2156,7 +2157,9 @@ template <>
 Status TypedColumnWriterImpl<ByteArrayType>::WriteArrowDense(
     const int16_t* def_levels, const int16_t* rep_levels, int64_t num_levels,
     const ::arrow::Array& array, ArrowWriteContext* ctx, bool maybe_parent_nulls) {
-  if (!::arrow::is_base_binary_like(array.type()->id())) {
+  if (!::arrow::is_base_binary_like(array.type()->id()) &&
+      array.type()->id() != ::arrow::Type::STRING_VIEW &&
+      array.type()->id() != ::arrow::Type::BINARY_VIEW) {
     ARROW_UNSUPPORTED();
   }
 
diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index 134a22f2841..1f7fff1dba2 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -43,6 +43,7 @@
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/rle_encoding.h"
+#include "arrow/util/span.h"
 #include "arrow/util/ubsan.h"
 #include "arrow/visit_data_inline.h"
 #include "parquet/exception.h"
@@ -148,10 +149,18 @@ class PlainEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
   }
 
  protected:
-  template <typename ArrayType>
+  template <typename ArrayType, bool IsView = ::arrow::is_binary_view_like_type<
+                                    typename ArrayType::TypeClass>::value>
   void PutBinaryArray(const ArrayType& array) {
-    const int64_t total_bytes =
-        array.value_offset(array.length()) - array.value_offset(0);
+    int64_t total_bytes = 0;
+    if constexpr (IsView) {
+      for (const auto& char_buffer :
+           ::arrow::util::span{array.data()->buffers}.subspan(2)) {
+        total_bytes += char_buffer->size();
+      }
+    } else {
+      total_bytes = array.value_offset(array.length()) - array.value_offset(0);
+    }
     PARQUET_THROW_NOT_OK(sink_.Reserve(total_bytes + array.length() * sizeof(uint32_t)));
 
     PARQUET_THROW_NOT_OK(::arrow::VisitArraySpanInline<typename ArrayType::TypeClass>(
@@ -160,7 +169,11 @@ class PlainEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
           if (ARROW_PREDICT_FALSE(view.size() > kMaxByteArraySize)) {
             return Status::Invalid("Parquet cannot store strings with size 2GB or more");
           }
-          UnsafePutByteArray(view.data(), static_cast<uint32_t>(view.size()));
+          if constexpr (IsView) {
+            Put(view);
+          } else {
+            UnsafePutByteArray(view.data(), static_cast<uint32_t>(view.size()));
+          }
           return Status::OK();
         },
         []() { return Status::OK(); }));
@@ -241,7 +254,9 @@ void PlainEncoder<DType>::Put(const ::arrow::Array& values) {
 }
 
 void AssertBaseBinary(const ::arrow::Array& values) {
-  if (!::arrow::is_base_binary_like(values.type_id())) {
+  if (!::arrow::is_base_binary_like(values.type_id()) &&
+      values.type()->id() != ::arrow::Type::STRING_VIEW &&
+      values.type()->id() != ::arrow::Type::BINARY_VIEW) {
     throw ParquetException("Only BaseBinaryArray and subclasses supported");
   }
 }
@@ -252,6 +267,9 @@ inline void PlainEncoder<ByteArrayType>::Put(const ::arrow::Array& values) {
 
   if (::arrow::is_binary_like(values.type_id())) {
     PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+  } else if (values.type_id() == ::arrow::Type::BINARY_VIEW ||
+             values.type_id() == ::arrow::Type::STRING_VIEW) {
+    PutBinaryArray(checked_cast<const ::arrow::BinaryViewArray&>(values));
   } else {
     DCHECK(::arrow::is_large_binary_like(values.type_id()));
     PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
@@ -793,6 +811,9 @@ void DictEncoderImpl<ByteArrayType>::Put(const ::arrow::Array& values) {
   AssertBaseBinary(values);
   if (::arrow::is_binary_like(values.type_id())) {
     PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+  } else if (values.type_id() == ::arrow::Type::BINARY_VIEW ||
+             values.type_id() == ::arrow::Type::STRING_VIEW) {
+    PutBinaryArray(checked_cast<const ::arrow::BinaryViewArray&>(values));
   } else {
     DCHECK(::arrow::is_large_binary_like(values.type_id()));
     PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
diff --git a/cpp/src/parquet/statistics.cc b/cpp/src/parquet/statistics.cc
index aa6df7e32a9..45446e013ae 100644
--- a/cpp/src/parquet/statistics.cc
+++ b/cpp/src/parquet/statistics.cc
@@ -437,6 +437,10 @@ std::pair<ByteArray, ByteArray> GetMinMaxBinaryHelper(
   if (::arrow::is_binary_like(values.type_id())) {
     ::arrow::VisitArraySpanInline<::arrow::BinaryType>(
         *values.data(), std::move(valid_func), std::move(null_func));
+  } else if (values.type_id() == ::arrow::Type::BINARY_VIEW ||
+             values.type_id() == ::arrow::Type::STRING_VIEW) {
+    ::arrow::VisitArraySpanInline<::arrow::BinaryViewType>(
+        *values.data(), std::move(valid_func), std::move(null_func));
   } else {
     DCHECK(::arrow::is_large_binary_like(values.type_id()));
     ::arrow::VisitArraySpanInline<::arrow::LargeBinaryType>(
diff --git a/cpp/src/plasma/common_generated.h b/cpp/src/plasma/common_generated.h
new file mode 100644
index 00000000000..ba9ef6e72d0
--- /dev/null
+++ b/cpp/src/plasma/common_generated.h
@@ -0,0 +1,230 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_COMMON_PLASMA_FLATBUF_H_
+#define FLATBUFFERS_GENERATED_COMMON_PLASMA_FLATBUF_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace plasma {
+namespace flatbuf {
+
+struct ObjectInfo;
+struct ObjectInfoBuilder;
+struct ObjectInfoT;
+
+struct ObjectInfoT : public flatbuffers::NativeTable {
+  typedef ObjectInfo TableType;
+  std::string object_id;
+  int64_t data_size;
+  int64_t metadata_size;
+  int32_t ref_count;
+  int64_t create_time;
+  int64_t construct_duration;
+  std::string digest;
+  bool is_deletion;
+  ObjectInfoT()
+      : data_size(0),
+        metadata_size(0),
+        ref_count(0),
+        create_time(0),
+        construct_duration(0),
+        is_deletion(false) {
+  }
+};
+
+struct ObjectInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef ObjectInfoT NativeTableType;
+  typedef ObjectInfoBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_DATA_SIZE = 6,
+    VT_METADATA_SIZE = 8,
+    VT_REF_COUNT = 10,
+    VT_CREATE_TIME = 12,
+    VT_CONSTRUCT_DURATION = 14,
+    VT_DIGEST = 16,
+    VT_IS_DELETION = 18
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  int64_t data_size() const {
+    return GetField<int64_t>(VT_DATA_SIZE, 0);
+  }
+  int64_t metadata_size() const {
+    return GetField<int64_t>(VT_METADATA_SIZE, 0);
+  }
+  int32_t ref_count() const {
+    return GetField<int32_t>(VT_REF_COUNT, 0);
+  }
+  int64_t create_time() const {
+    return GetField<int64_t>(VT_CREATE_TIME, 0);
+  }
+  int64_t construct_duration() const {
+    return GetField<int64_t>(VT_CONSTRUCT_DURATION, 0);
+  }
+  const flatbuffers::String *digest() const {
+    return GetPointer<const flatbuffers::String *>(VT_DIGEST);
+  }
+  bool is_deletion() const {
+    return GetField<uint8_t>(VT_IS_DELETION, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyField<int64_t>(verifier, VT_DATA_SIZE) &&
+           VerifyField<int64_t>(verifier, VT_METADATA_SIZE) &&
+           VerifyField<int32_t>(verifier, VT_REF_COUNT) &&
+           VerifyField<int64_t>(verifier, VT_CREATE_TIME) &&
+           VerifyField<int64_t>(verifier, VT_CONSTRUCT_DURATION) &&
+           VerifyOffset(verifier, VT_DIGEST) &&
+           verifier.VerifyString(digest()) &&
+           VerifyField<uint8_t>(verifier, VT_IS_DELETION) &&
+           verifier.EndTable();
+  }
+  ObjectInfoT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(ObjectInfoT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<ObjectInfo> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ObjectInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct ObjectInfoBuilder {
+  typedef ObjectInfo Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(ObjectInfo::VT_OBJECT_ID, object_id);
+  }
+  void add_data_size(int64_t data_size) {
+    fbb_.AddElement<int64_t>(ObjectInfo::VT_DATA_SIZE, data_size, 0);
+  }
+  void add_metadata_size(int64_t metadata_size) {
+    fbb_.AddElement<int64_t>(ObjectInfo::VT_METADATA_SIZE, metadata_size, 0);
+  }
+  void add_ref_count(int32_t ref_count) {
+    fbb_.AddElement<int32_t>(ObjectInfo::VT_REF_COUNT, ref_count, 0);
+  }
+  void add_create_time(int64_t create_time) {
+    fbb_.AddElement<int64_t>(ObjectInfo::VT_CREATE_TIME, create_time, 0);
+  }
+  void add_construct_duration(int64_t construct_duration) {
+    fbb_.AddElement<int64_t>(ObjectInfo::VT_CONSTRUCT_DURATION, construct_duration, 0);
+  }
+  void add_digest(flatbuffers::Offset<flatbuffers::String> digest) {
+    fbb_.AddOffset(ObjectInfo::VT_DIGEST, digest);
+  }
+  void add_is_deletion(bool is_deletion) {
+    fbb_.AddElement<uint8_t>(ObjectInfo::VT_IS_DELETION, static_cast<uint8_t>(is_deletion), 0);
+  }
+  explicit ObjectInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ObjectInfoBuilder &operator=(const ObjectInfoBuilder &);
+  flatbuffers::Offset<ObjectInfo> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<ObjectInfo>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<ObjectInfo> CreateObjectInfo(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    int64_t data_size = 0,
+    int64_t metadata_size = 0,
+    int32_t ref_count = 0,
+    int64_t create_time = 0,
+    int64_t construct_duration = 0,
+    flatbuffers::Offset<flatbuffers::String> digest = 0,
+    bool is_deletion = false) {
+  ObjectInfoBuilder builder_(_fbb);
+  builder_.add_construct_duration(construct_duration);
+  builder_.add_create_time(create_time);
+  builder_.add_metadata_size(metadata_size);
+  builder_.add_data_size(data_size);
+  builder_.add_digest(digest);
+  builder_.add_ref_count(ref_count);
+  builder_.add_object_id(object_id);
+  builder_.add_is_deletion(is_deletion);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<ObjectInfo> CreateObjectInfoDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    int64_t data_size = 0,
+    int64_t metadata_size = 0,
+    int32_t ref_count = 0,
+    int64_t create_time = 0,
+    int64_t construct_duration = 0,
+    const char *digest = nullptr,
+    bool is_deletion = false) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  auto digest__ = digest ? _fbb.CreateString(digest) : 0;
+  return plasma::flatbuf::CreateObjectInfo(
+      _fbb,
+      object_id__,
+      data_size,
+      metadata_size,
+      ref_count,
+      create_time,
+      construct_duration,
+      digest__,
+      is_deletion);
+}
+
+flatbuffers::Offset<ObjectInfo> CreateObjectInfo(flatbuffers::FlatBufferBuilder &_fbb, const ObjectInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+inline ObjectInfoT *ObjectInfo::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::ObjectInfoT> _o = std::unique_ptr<plasma::flatbuf::ObjectInfoT>(new ObjectInfoT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void ObjectInfo::UnPackTo(ObjectInfoT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = data_size(); _o->data_size = _e; }
+  { auto _e = metadata_size(); _o->metadata_size = _e; }
+  { auto _e = ref_count(); _o->ref_count = _e; }
+  { auto _e = create_time(); _o->create_time = _e; }
+  { auto _e = construct_duration(); _o->construct_duration = _e; }
+  { auto _e = digest(); if (_e) _o->digest = _e->str(); }
+  { auto _e = is_deletion(); _o->is_deletion = _e; }
+}
+
+inline flatbuffers::Offset<ObjectInfo> ObjectInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ObjectInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateObjectInfo(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<ObjectInfo> CreateObjectInfo(flatbuffers::FlatBufferBuilder &_fbb, const ObjectInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ObjectInfoT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _data_size = _o->data_size;
+  auto _metadata_size = _o->metadata_size;
+  auto _ref_count = _o->ref_count;
+  auto _create_time = _o->create_time;
+  auto _construct_duration = _o->construct_duration;
+  auto _digest = _o->digest.empty() ? 0 : _fbb.CreateString(_o->digest);
+  auto _is_deletion = _o->is_deletion;
+  return plasma::flatbuf::CreateObjectInfo(
+      _fbb,
+      _object_id,
+      _data_size,
+      _metadata_size,
+      _ref_count,
+      _create_time,
+      _construct_duration,
+      _digest,
+      _is_deletion);
+}
+
+}  // namespace flatbuf
+}  // namespace plasma
+
+#endif  // FLATBUFFERS_GENERATED_COMMON_PLASMA_FLATBUF_H_
diff --git a/cpp/src/plasma/plasma_generated.h b/cpp/src/plasma/plasma_generated.h
new file mode 100644
index 00000000000..340f043bc83
--- /dev/null
+++ b/cpp/src/plasma/plasma_generated.h
@@ -0,0 +1,3984 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_PLASMA_PLASMA_FLATBUF_H_
+#define FLATBUFFERS_GENERATED_PLASMA_PLASMA_FLATBUF_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "common_generated.h"
+
+namespace plasma {
+namespace flatbuf {
+
+struct PlasmaObjectSpec;
+
+struct PlasmaSetOptionsRequest;
+struct PlasmaSetOptionsRequestBuilder;
+struct PlasmaSetOptionsRequestT;
+
+struct PlasmaSetOptionsReply;
+struct PlasmaSetOptionsReplyBuilder;
+struct PlasmaSetOptionsReplyT;
+
+struct PlasmaGetDebugStringRequest;
+struct PlasmaGetDebugStringRequestBuilder;
+struct PlasmaGetDebugStringRequestT;
+
+struct PlasmaGetDebugStringReply;
+struct PlasmaGetDebugStringReplyBuilder;
+struct PlasmaGetDebugStringReplyT;
+
+struct PlasmaCreateRequest;
+struct PlasmaCreateRequestBuilder;
+struct PlasmaCreateRequestT;
+
+struct CudaHandle;
+struct CudaHandleBuilder;
+struct CudaHandleT;
+
+struct PlasmaCreateReply;
+struct PlasmaCreateReplyBuilder;
+struct PlasmaCreateReplyT;
+
+struct PlasmaCreateAndSealRequest;
+struct PlasmaCreateAndSealRequestBuilder;
+struct PlasmaCreateAndSealRequestT;
+
+struct PlasmaCreateAndSealReply;
+struct PlasmaCreateAndSealReplyBuilder;
+struct PlasmaCreateAndSealReplyT;
+
+struct PlasmaCreateAndSealBatchRequest;
+struct PlasmaCreateAndSealBatchRequestBuilder;
+struct PlasmaCreateAndSealBatchRequestT;
+
+struct PlasmaCreateAndSealBatchReply;
+struct PlasmaCreateAndSealBatchReplyBuilder;
+struct PlasmaCreateAndSealBatchReplyT;
+
+struct PlasmaAbortRequest;
+struct PlasmaAbortRequestBuilder;
+struct PlasmaAbortRequestT;
+
+struct PlasmaAbortReply;
+struct PlasmaAbortReplyBuilder;
+struct PlasmaAbortReplyT;
+
+struct PlasmaSealRequest;
+struct PlasmaSealRequestBuilder;
+struct PlasmaSealRequestT;
+
+struct PlasmaSealReply;
+struct PlasmaSealReplyBuilder;
+struct PlasmaSealReplyT;
+
+struct PlasmaGetRequest;
+struct PlasmaGetRequestBuilder;
+struct PlasmaGetRequestT;
+
+struct PlasmaGetReply;
+struct PlasmaGetReplyBuilder;
+struct PlasmaGetReplyT;
+
+struct PlasmaReleaseRequest;
+struct PlasmaReleaseRequestBuilder;
+struct PlasmaReleaseRequestT;
+
+struct PlasmaReleaseReply;
+struct PlasmaReleaseReplyBuilder;
+struct PlasmaReleaseReplyT;
+
+struct PlasmaDeleteRequest;
+struct PlasmaDeleteRequestBuilder;
+struct PlasmaDeleteRequestT;
+
+struct PlasmaDeleteReply;
+struct PlasmaDeleteReplyBuilder;
+struct PlasmaDeleteReplyT;
+
+struct PlasmaContainsRequest;
+struct PlasmaContainsRequestBuilder;
+struct PlasmaContainsRequestT;
+
+struct PlasmaContainsReply;
+struct PlasmaContainsReplyBuilder;
+struct PlasmaContainsReplyT;
+
+struct PlasmaListRequest;
+struct PlasmaListRequestBuilder;
+struct PlasmaListRequestT;
+
+struct PlasmaListReply;
+struct PlasmaListReplyBuilder;
+struct PlasmaListReplyT;
+
+struct PlasmaConnectRequest;
+struct PlasmaConnectRequestBuilder;
+struct PlasmaConnectRequestT;
+
+struct PlasmaConnectReply;
+struct PlasmaConnectReplyBuilder;
+struct PlasmaConnectReplyT;
+
+struct PlasmaEvictRequest;
+struct PlasmaEvictRequestBuilder;
+struct PlasmaEvictRequestT;
+
+struct PlasmaEvictReply;
+struct PlasmaEvictReplyBuilder;
+struct PlasmaEvictReplyT;
+
+struct PlasmaSubscribeRequest;
+struct PlasmaSubscribeRequestBuilder;
+struct PlasmaSubscribeRequestT;
+
+struct PlasmaNotification;
+struct PlasmaNotificationBuilder;
+struct PlasmaNotificationT;
+
+struct PlasmaDataRequest;
+struct PlasmaDataRequestBuilder;
+struct PlasmaDataRequestT;
+
+struct PlasmaDataReply;
+struct PlasmaDataReplyBuilder;
+struct PlasmaDataReplyT;
+
+struct PlasmaRefreshLRURequest;
+struct PlasmaRefreshLRURequestBuilder;
+struct PlasmaRefreshLRURequestT;
+
+struct PlasmaRefreshLRUReply;
+struct PlasmaRefreshLRUReplyBuilder;
+struct PlasmaRefreshLRUReplyT;
+
+enum class MessageType : int64_t {
+  PlasmaDisconnectClient = 0,
+  PlasmaCreateRequest = 1LL,
+  PlasmaCreateReply = 2LL,
+  PlasmaCreateAndSealRequest = 3LL,
+  PlasmaCreateAndSealReply = 4LL,
+  PlasmaAbortRequest = 5LL,
+  PlasmaAbortReply = 6LL,
+  PlasmaSealRequest = 7LL,
+  PlasmaSealReply = 8LL,
+  PlasmaGetRequest = 9LL,
+  PlasmaGetReply = 10LL,
+  PlasmaReleaseRequest = 11LL,
+  PlasmaReleaseReply = 12LL,
+  PlasmaDeleteRequest = 13LL,
+  PlasmaDeleteReply = 14LL,
+  PlasmaContainsRequest = 15LL,
+  PlasmaContainsReply = 16LL,
+  PlasmaListRequest = 17LL,
+  PlasmaListReply = 18LL,
+  PlasmaConnectRequest = 19LL,
+  PlasmaConnectReply = 20LL,
+  PlasmaEvictRequest = 21LL,
+  PlasmaEvictReply = 22LL,
+  PlasmaSubscribeRequest = 23LL,
+  PlasmaUnsubscribeRequest = 24LL,
+  PlasmaDataRequest = 25LL,
+  PlasmaDataReply = 26LL,
+  PlasmaNotification = 27LL,
+  PlasmaSetOptionsRequest = 28LL,
+  PlasmaSetOptionsReply = 29LL,
+  PlasmaGetDebugStringRequest = 30LL,
+  PlasmaGetDebugStringReply = 31LL,
+  PlasmaCreateAndSealBatchRequest = 32LL,
+  PlasmaCreateAndSealBatchReply = 33LL,
+  PlasmaRefreshLRURequest = 34LL,
+  PlasmaRefreshLRUReply = 35LL,
+  MIN = PlasmaDisconnectClient,
+  MAX = PlasmaRefreshLRUReply
+};
+
+inline const MessageType (&EnumValuesMessageType())[36] {
+  static const MessageType values[] = {
+    MessageType::PlasmaDisconnectClient,
+    MessageType::PlasmaCreateRequest,
+    MessageType::PlasmaCreateReply,
+    MessageType::PlasmaCreateAndSealRequest,
+    MessageType::PlasmaCreateAndSealReply,
+    MessageType::PlasmaAbortRequest,
+    MessageType::PlasmaAbortReply,
+    MessageType::PlasmaSealRequest,
+    MessageType::PlasmaSealReply,
+    MessageType::PlasmaGetRequest,
+    MessageType::PlasmaGetReply,
+    MessageType::PlasmaReleaseRequest,
+    MessageType::PlasmaReleaseReply,
+    MessageType::PlasmaDeleteRequest,
+    MessageType::PlasmaDeleteReply,
+    MessageType::PlasmaContainsRequest,
+    MessageType::PlasmaContainsReply,
+    MessageType::PlasmaListRequest,
+    MessageType::PlasmaListReply,
+    MessageType::PlasmaConnectRequest,
+    MessageType::PlasmaConnectReply,
+    MessageType::PlasmaEvictRequest,
+    MessageType::PlasmaEvictReply,
+    MessageType::PlasmaSubscribeRequest,
+    MessageType::PlasmaUnsubscribeRequest,
+    MessageType::PlasmaDataRequest,
+    MessageType::PlasmaDataReply,
+    MessageType::PlasmaNotification,
+    MessageType::PlasmaSetOptionsRequest,
+    MessageType::PlasmaSetOptionsReply,
+    MessageType::PlasmaGetDebugStringRequest,
+    MessageType::PlasmaGetDebugStringReply,
+    MessageType::PlasmaCreateAndSealBatchRequest,
+    MessageType::PlasmaCreateAndSealBatchReply,
+    MessageType::PlasmaRefreshLRURequest,
+    MessageType::PlasmaRefreshLRUReply
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesMessageType() {
+  static const char * const names[37] = {
+    "PlasmaDisconnectClient",
+    "PlasmaCreateRequest",
+    "PlasmaCreateReply",
+    "PlasmaCreateAndSealRequest",
+    "PlasmaCreateAndSealReply",
+    "PlasmaAbortRequest",
+    "PlasmaAbortReply",
+    "PlasmaSealRequest",
+    "PlasmaSealReply",
+    "PlasmaGetRequest",
+    "PlasmaGetReply",
+    "PlasmaReleaseRequest",
+    "PlasmaReleaseReply",
+    "PlasmaDeleteRequest",
+    "PlasmaDeleteReply",
+    "PlasmaContainsRequest",
+    "PlasmaContainsReply",
+    "PlasmaListRequest",
+    "PlasmaListReply",
+    "PlasmaConnectRequest",
+    "PlasmaConnectReply",
+    "PlasmaEvictRequest",
+    "PlasmaEvictReply",
+    "PlasmaSubscribeRequest",
+    "PlasmaUnsubscribeRequest",
+    "PlasmaDataRequest",
+    "PlasmaDataReply",
+    "PlasmaNotification",
+    "PlasmaSetOptionsRequest",
+    "PlasmaSetOptionsReply",
+    "PlasmaGetDebugStringRequest",
+    "PlasmaGetDebugStringReply",
+    "PlasmaCreateAndSealBatchRequest",
+    "PlasmaCreateAndSealBatchReply",
+    "PlasmaRefreshLRURequest",
+    "PlasmaRefreshLRUReply",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameMessageType(MessageType e) {
+  if (flatbuffers::IsOutRange(e, MessageType::PlasmaDisconnectClient, MessageType::PlasmaRefreshLRUReply)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesMessageType()[index];
+}
+
+enum class PlasmaError : int32_t {
+  OK = 0,
+  ObjectExists = 1,
+  ObjectNotFound = 2,
+  OutOfMemory = 3,
+  ObjectNotSealed = 4,
+  ObjectInUse = 5,
+  MIN = OK,
+  MAX = ObjectInUse
+};
+
+inline const PlasmaError (&EnumValuesPlasmaError())[6] {
+  static const PlasmaError values[] = {
+    PlasmaError::OK,
+    PlasmaError::ObjectExists,
+    PlasmaError::ObjectNotFound,
+    PlasmaError::OutOfMemory,
+    PlasmaError::ObjectNotSealed,
+    PlasmaError::ObjectInUse
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesPlasmaError() {
+  static const char * const names[7] = {
+    "OK",
+    "ObjectExists",
+    "ObjectNotFound",
+    "OutOfMemory",
+    "ObjectNotSealed",
+    "ObjectInUse",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNamePlasmaError(PlasmaError e) {
+  if (flatbuffers::IsOutRange(e, PlasmaError::OK, PlasmaError::ObjectInUse)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesPlasmaError()[index];
+}
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) PlasmaObjectSpec FLATBUFFERS_FINAL_CLASS {
+ private:
+  int32_t segment_index_;
+  int32_t padding0__;
+  uint64_t data_offset_;
+  uint64_t data_size_;
+  uint64_t metadata_offset_;
+  uint64_t metadata_size_;
+  int32_t device_num_;
+  int32_t padding1__;
+
+ public:
+  PlasmaObjectSpec() {
+    memset(static_cast<void *>(this), 0, sizeof(PlasmaObjectSpec));
+  }
+  PlasmaObjectSpec(int32_t _segment_index, uint64_t _data_offset, uint64_t _data_size, uint64_t _metadata_offset, uint64_t _metadata_size, int32_t _device_num)
+      : segment_index_(flatbuffers::EndianScalar(_segment_index)),
+        padding0__(0),
+        data_offset_(flatbuffers::EndianScalar(_data_offset)),
+        data_size_(flatbuffers::EndianScalar(_data_size)),
+        metadata_offset_(flatbuffers::EndianScalar(_metadata_offset)),
+        metadata_size_(flatbuffers::EndianScalar(_metadata_size)),
+        device_num_(flatbuffers::EndianScalar(_device_num)),
+        padding1__(0) {
+    (void)padding0__;
+    (void)padding1__;
+  }
+  int32_t segment_index() const {
+    return flatbuffers::EndianScalar(segment_index_);
+  }
+  uint64_t data_offset() const {
+    return flatbuffers::EndianScalar(data_offset_);
+  }
+  uint64_t data_size() const {
+    return flatbuffers::EndianScalar(data_size_);
+  }
+  uint64_t metadata_offset() const {
+    return flatbuffers::EndianScalar(metadata_offset_);
+  }
+  uint64_t metadata_size() const {
+    return flatbuffers::EndianScalar(metadata_size_);
+  }
+  int32_t device_num() const {
+    return flatbuffers::EndianScalar(device_num_);
+  }
+};
+FLATBUFFERS_STRUCT_END(PlasmaObjectSpec, 48);
+
+struct PlasmaSetOptionsRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaSetOptionsRequest TableType;
+  std::string client_name;
+  int64_t output_memory_quota;
+  PlasmaSetOptionsRequestT()
+      : output_memory_quota(0) {
+  }
+};
+
+struct PlasmaSetOptionsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaSetOptionsRequestT NativeTableType;
+  typedef PlasmaSetOptionsRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_CLIENT_NAME = 4,
+    VT_OUTPUT_MEMORY_QUOTA = 6
+  };
+  const flatbuffers::String *client_name() const {
+    return GetPointer<const flatbuffers::String *>(VT_CLIENT_NAME);
+  }
+  int64_t output_memory_quota() const {
+    return GetField<int64_t>(VT_OUTPUT_MEMORY_QUOTA, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_CLIENT_NAME) &&
+           verifier.VerifyString(client_name()) &&
+           VerifyField<int64_t>(verifier, VT_OUTPUT_MEMORY_QUOTA) &&
+           verifier.EndTable();
+  }
+  PlasmaSetOptionsRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaSetOptionsRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaSetOptionsRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaSetOptionsRequestBuilder {
+  typedef PlasmaSetOptionsRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_client_name(flatbuffers::Offset<flatbuffers::String> client_name) {
+    fbb_.AddOffset(PlasmaSetOptionsRequest::VT_CLIENT_NAME, client_name);
+  }
+  void add_output_memory_quota(int64_t output_memory_quota) {
+    fbb_.AddElement<int64_t>(PlasmaSetOptionsRequest::VT_OUTPUT_MEMORY_QUOTA, output_memory_quota, 0);
+  }
+  explicit PlasmaSetOptionsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaSetOptionsRequestBuilder &operator=(const PlasmaSetOptionsRequestBuilder &);
+  flatbuffers::Offset<PlasmaSetOptionsRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaSetOptionsRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> client_name = 0,
+    int64_t output_memory_quota = 0) {
+  PlasmaSetOptionsRequestBuilder builder_(_fbb);
+  builder_.add_output_memory_quota(output_memory_quota);
+  builder_.add_client_name(client_name);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *client_name = nullptr,
+    int64_t output_memory_quota = 0) {
+  auto client_name__ = client_name ? _fbb.CreateString(client_name) : 0;
+  return plasma::flatbuf::CreatePlasmaSetOptionsRequest(
+      _fbb,
+      client_name__,
+      output_memory_quota);
+}
+
+flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaSetOptionsReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaSetOptionsReply TableType;
+  plasma::flatbuf::PlasmaError error;
+  PlasmaSetOptionsReplyT()
+      : error(plasma::flatbuf::PlasmaError::OK) {
+  }
+};
+
+struct PlasmaSetOptionsReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaSetOptionsReplyT NativeTableType;
+  typedef PlasmaSetOptionsReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ERROR = 4
+  };
+  plasma::flatbuf::PlasmaError error() const {
+    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_ERROR) &&
+           verifier.EndTable();
+  }
+  PlasmaSetOptionsReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaSetOptionsReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaSetOptionsReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaSetOptionsReplyBuilder {
+  typedef PlasmaSetOptionsReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_error(plasma::flatbuf::PlasmaError error) {
+    fbb_.AddElement<int32_t>(PlasmaSetOptionsReply::VT_ERROR, static_cast<int32_t>(error), 0);
+  }
+  explicit PlasmaSetOptionsReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaSetOptionsReplyBuilder &operator=(const PlasmaSetOptionsReplyBuilder &);
+  flatbuffers::Offset<PlasmaSetOptionsReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaSetOptionsReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
+  PlasmaSetOptionsReplyBuilder builder_(_fbb);
+  builder_.add_error(error);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaGetDebugStringRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaGetDebugStringRequest TableType;
+  PlasmaGetDebugStringRequestT() {
+  }
+};
+
+struct PlasmaGetDebugStringRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaGetDebugStringRequestT NativeTableType;
+  typedef PlasmaGetDebugStringRequestBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+  PlasmaGetDebugStringRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaGetDebugStringRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaGetDebugStringRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaGetDebugStringRequestBuilder {
+  typedef PlasmaGetDebugStringRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit PlasmaGetDebugStringRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaGetDebugStringRequestBuilder &operator=(const PlasmaGetDebugStringRequestBuilder &);
+  flatbuffers::Offset<PlasmaGetDebugStringRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaGetDebugStringRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStringRequest(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  PlasmaGetDebugStringRequestBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStringRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaGetDebugStringReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaGetDebugStringReply TableType;
+  std::string debug_string;
+  PlasmaGetDebugStringReplyT() {
+  }
+};
+
+struct PlasmaGetDebugStringReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaGetDebugStringReplyT NativeTableType;
+  typedef PlasmaGetDebugStringReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_DEBUG_STRING = 4
+  };
+  const flatbuffers::String *debug_string() const {
+    return GetPointer<const flatbuffers::String *>(VT_DEBUG_STRING);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_DEBUG_STRING) &&
+           verifier.VerifyString(debug_string()) &&
+           verifier.EndTable();
+  }
+  PlasmaGetDebugStringReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaGetDebugStringReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaGetDebugStringReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaGetDebugStringReplyBuilder {
+  typedef PlasmaGetDebugStringReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_debug_string(flatbuffers::Offset<flatbuffers::String> debug_string) {
+    fbb_.AddOffset(PlasmaGetDebugStringReply::VT_DEBUG_STRING, debug_string);
+  }
+  explicit PlasmaGetDebugStringReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaGetDebugStringReplyBuilder &operator=(const PlasmaGetDebugStringReplyBuilder &);
+  flatbuffers::Offset<PlasmaGetDebugStringReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaGetDebugStringReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> debug_string = 0) {
+  PlasmaGetDebugStringReplyBuilder builder_(_fbb);
+  builder_.add_debug_string(debug_string);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *debug_string = nullptr) {
+  auto debug_string__ = debug_string ? _fbb.CreateString(debug_string) : 0;
+  return plasma::flatbuf::CreatePlasmaGetDebugStringReply(
+      _fbb,
+      debug_string__);
+}
+
+flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaCreateRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaCreateRequest TableType;
+  std::string object_id;
+  bool evict_if_full;
+  uint64_t data_size;
+  uint64_t metadata_size;
+  int32_t device_num;
+  PlasmaCreateRequestT()
+      : evict_if_full(false),
+        data_size(0),
+        metadata_size(0),
+        device_num(0) {
+  }
+};
+
+struct PlasmaCreateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaCreateRequestT NativeTableType;
+  typedef PlasmaCreateRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_EVICT_IF_FULL = 6,
+    VT_DATA_SIZE = 8,
+    VT_METADATA_SIZE = 10,
+    VT_DEVICE_NUM = 12
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  bool evict_if_full() const {
+    return GetField<uint8_t>(VT_EVICT_IF_FULL, 0) != 0;
+  }
+  uint64_t data_size() const {
+    return GetField<uint64_t>(VT_DATA_SIZE, 0);
+  }
+  uint64_t metadata_size() const {
+    return GetField<uint64_t>(VT_METADATA_SIZE, 0);
+  }
+  int32_t device_num() const {
+    return GetField<int32_t>(VT_DEVICE_NUM, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyField<uint8_t>(verifier, VT_EVICT_IF_FULL) &&
+           VerifyField<uint64_t>(verifier, VT_DATA_SIZE) &&
+           VerifyField<uint64_t>(verifier, VT_METADATA_SIZE) &&
+           VerifyField<int32_t>(verifier, VT_DEVICE_NUM) &&
+           verifier.EndTable();
+  }
+  PlasmaCreateRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaCreateRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaCreateRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaCreateRequestBuilder {
+  typedef PlasmaCreateRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaCreateRequest::VT_OBJECT_ID, object_id);
+  }
+  void add_evict_if_full(bool evict_if_full) {
+    fbb_.AddElement<uint8_t>(PlasmaCreateRequest::VT_EVICT_IF_FULL, static_cast<uint8_t>(evict_if_full), 0);
+  }
+  void add_data_size(uint64_t data_size) {
+    fbb_.AddElement<uint64_t>(PlasmaCreateRequest::VT_DATA_SIZE, data_size, 0);
+  }
+  void add_metadata_size(uint64_t metadata_size) {
+    fbb_.AddElement<uint64_t>(PlasmaCreateRequest::VT_METADATA_SIZE, metadata_size, 0);
+  }
+  void add_device_num(int32_t device_num) {
+    fbb_.AddElement<int32_t>(PlasmaCreateRequest::VT_DEVICE_NUM, device_num, 0);
+  }
+  explicit PlasmaCreateRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaCreateRequestBuilder &operator=(const PlasmaCreateRequestBuilder &);
+  flatbuffers::Offset<PlasmaCreateRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaCreateRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    bool evict_if_full = false,
+    uint64_t data_size = 0,
+    uint64_t metadata_size = 0,
+    int32_t device_num = 0) {
+  PlasmaCreateRequestBuilder builder_(_fbb);
+  builder_.add_metadata_size(metadata_size);
+  builder_.add_data_size(data_size);
+  builder_.add_device_num(device_num);
+  builder_.add_object_id(object_id);
+  builder_.add_evict_if_full(evict_if_full);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    bool evict_if_full = false,
+    uint64_t data_size = 0,
+    uint64_t metadata_size = 0,
+    int32_t device_num = 0) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaCreateRequest(
+      _fbb,
+      object_id__,
+      evict_if_full,
+      data_size,
+      metadata_size,
+      device_num);
+}
+
+flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct CudaHandleT : public flatbuffers::NativeTable {
+  typedef CudaHandle TableType;
+  std::vector<uint8_t> handle;
+  CudaHandleT() {
+  }
+};
+
+struct CudaHandle FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef CudaHandleT NativeTableType;
+  typedef CudaHandleBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_HANDLE = 4
+  };
+  const flatbuffers::Vector<uint8_t> *handle() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_HANDLE);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_HANDLE) &&
+           verifier.VerifyVector(handle()) &&
+           verifier.EndTable();
+  }
+  CudaHandleT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(CudaHandleT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<CudaHandle> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CudaHandleT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct CudaHandleBuilder {
+  typedef CudaHandle Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_handle(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> handle) {
+    fbb_.AddOffset(CudaHandle::VT_HANDLE, handle);
+  }
+  explicit CudaHandleBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  CudaHandleBuilder &operator=(const CudaHandleBuilder &);
+  flatbuffers::Offset<CudaHandle> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<CudaHandle>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<CudaHandle> CreateCudaHandle(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> handle = 0) {
+  CudaHandleBuilder builder_(_fbb);
+  builder_.add_handle(handle);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<CudaHandle> CreateCudaHandleDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint8_t> *handle = nullptr) {
+  auto handle__ = handle ? _fbb.CreateVector<uint8_t>(*handle) : 0;
+  return plasma::flatbuf::CreateCudaHandle(
+      _fbb,
+      handle__);
+}
+
+flatbuffers::Offset<CudaHandle> CreateCudaHandle(flatbuffers::FlatBufferBuilder &_fbb, const CudaHandleT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaCreateReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaCreateReply TableType;
+  std::string object_id;
+  std::unique_ptr<plasma::flatbuf::PlasmaObjectSpec> plasma_object;
+  plasma::flatbuf::PlasmaError error;
+  int32_t store_fd;
+  int64_t mmap_size;
+  std::unique_ptr<plasma::flatbuf::CudaHandleT> ipc_handle;
+  PlasmaCreateReplyT()
+      : error(plasma::flatbuf::PlasmaError::OK),
+        store_fd(0),
+        mmap_size(0) {
+  }
+};
+
+struct PlasmaCreateReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaCreateReplyT NativeTableType;
+  typedef PlasmaCreateReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_PLASMA_OBJECT = 6,
+    VT_ERROR = 8,
+    VT_STORE_FD = 10,
+    VT_MMAP_SIZE = 12,
+    VT_IPC_HANDLE = 14
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  const plasma::flatbuf::PlasmaObjectSpec *plasma_object() const {
+    return GetStruct<const plasma::flatbuf::PlasmaObjectSpec *>(VT_PLASMA_OBJECT);
+  }
+  plasma::flatbuf::PlasmaError error() const {
+    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
+  }
+  int32_t store_fd() const {
+    return GetField<int32_t>(VT_STORE_FD, 0);
+  }
+  int64_t mmap_size() const {
+    return GetField<int64_t>(VT_MMAP_SIZE, 0);
+  }
+  const plasma::flatbuf::CudaHandle *ipc_handle() const {
+    return GetPointer<const plasma::flatbuf::CudaHandle *>(VT_IPC_HANDLE);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyField<plasma::flatbuf::PlasmaObjectSpec>(verifier, VT_PLASMA_OBJECT) &&
+           VerifyField<int32_t>(verifier, VT_ERROR) &&
+           VerifyField<int32_t>(verifier, VT_STORE_FD) &&
+           VerifyField<int64_t>(verifier, VT_MMAP_SIZE) &&
+           VerifyOffset(verifier, VT_IPC_HANDLE) &&
+           verifier.VerifyTable(ipc_handle()) &&
+           verifier.EndTable();
+  }
+  PlasmaCreateReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaCreateReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaCreateReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaCreateReplyBuilder {
+  typedef PlasmaCreateReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaCreateReply::VT_OBJECT_ID, object_id);
+  }
+  void add_plasma_object(const plasma::flatbuf::PlasmaObjectSpec *plasma_object) {
+    fbb_.AddStruct(PlasmaCreateReply::VT_PLASMA_OBJECT, plasma_object);
+  }
+  void add_error(plasma::flatbuf::PlasmaError error) {
+    fbb_.AddElement<int32_t>(PlasmaCreateReply::VT_ERROR, static_cast<int32_t>(error), 0);
+  }
+  void add_store_fd(int32_t store_fd) {
+    fbb_.AddElement<int32_t>(PlasmaCreateReply::VT_STORE_FD, store_fd, 0);
+  }
+  void add_mmap_size(int64_t mmap_size) {
+    fbb_.AddElement<int64_t>(PlasmaCreateReply::VT_MMAP_SIZE, mmap_size, 0);
+  }
+  void add_ipc_handle(flatbuffers::Offset<plasma::flatbuf::CudaHandle> ipc_handle) {
+    fbb_.AddOffset(PlasmaCreateReply::VT_IPC_HANDLE, ipc_handle);
+  }
+  explicit PlasmaCreateReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaCreateReplyBuilder &operator=(const PlasmaCreateReplyBuilder &);
+  flatbuffers::Offset<PlasmaCreateReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaCreateReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    const plasma::flatbuf::PlasmaObjectSpec *plasma_object = 0,
+    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK,
+    int32_t store_fd = 0,
+    int64_t mmap_size = 0,
+    flatbuffers::Offset<plasma::flatbuf::CudaHandle> ipc_handle = 0) {
+  PlasmaCreateReplyBuilder builder_(_fbb);
+  builder_.add_mmap_size(mmap_size);
+  builder_.add_ipc_handle(ipc_handle);
+  builder_.add_store_fd(store_fd);
+  builder_.add_error(error);
+  builder_.add_plasma_object(plasma_object);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    const plasma::flatbuf::PlasmaObjectSpec *plasma_object = 0,
+    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK,
+    int32_t store_fd = 0,
+    int64_t mmap_size = 0,
+    flatbuffers::Offset<plasma::flatbuf::CudaHandle> ipc_handle = 0) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaCreateReply(
+      _fbb,
+      object_id__,
+      plasma_object,
+      error,
+      store_fd,
+      mmap_size,
+      ipc_handle);
+}
+
+flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaCreateAndSealRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaCreateAndSealRequest TableType;
+  std::string object_id;
+  bool evict_if_full;
+  std::string data;
+  std::string metadata;
+  std::string digest;
+  PlasmaCreateAndSealRequestT()
+      : evict_if_full(false) {
+  }
+};
+
+struct PlasmaCreateAndSealRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaCreateAndSealRequestT NativeTableType;
+  typedef PlasmaCreateAndSealRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_EVICT_IF_FULL = 6,
+    VT_DATA = 8,
+    VT_METADATA = 10,
+    VT_DIGEST = 12
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  bool evict_if_full() const {
+    return GetField<uint8_t>(VT_EVICT_IF_FULL, 0) != 0;
+  }
+  const flatbuffers::String *data() const {
+    return GetPointer<const flatbuffers::String *>(VT_DATA);
+  }
+  const flatbuffers::String *metadata() const {
+    return GetPointer<const flatbuffers::String *>(VT_METADATA);
+  }
+  const flatbuffers::String *digest() const {
+    return GetPointer<const flatbuffers::String *>(VT_DIGEST);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyField<uint8_t>(verifier, VT_EVICT_IF_FULL) &&
+           VerifyOffset(verifier, VT_DATA) &&
+           verifier.VerifyString(data()) &&
+           VerifyOffset(verifier, VT_METADATA) &&
+           verifier.VerifyString(metadata()) &&
+           VerifyOffset(verifier, VT_DIGEST) &&
+           verifier.VerifyString(digest()) &&
+           verifier.EndTable();
+  }
+  PlasmaCreateAndSealRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaCreateAndSealRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaCreateAndSealRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaCreateAndSealRequestBuilder {
+  typedef PlasmaCreateAndSealRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaCreateAndSealRequest::VT_OBJECT_ID, object_id);
+  }
+  void add_evict_if_full(bool evict_if_full) {
+    fbb_.AddElement<uint8_t>(PlasmaCreateAndSealRequest::VT_EVICT_IF_FULL, static_cast<uint8_t>(evict_if_full), 0);
+  }
+  void add_data(flatbuffers::Offset<flatbuffers::String> data) {
+    fbb_.AddOffset(PlasmaCreateAndSealRequest::VT_DATA, data);
+  }
+  void add_metadata(flatbuffers::Offset<flatbuffers::String> metadata) {
+    fbb_.AddOffset(PlasmaCreateAndSealRequest::VT_METADATA, metadata);
+  }
+  void add_digest(flatbuffers::Offset<flatbuffers::String> digest) {
+    fbb_.AddOffset(PlasmaCreateAndSealRequest::VT_DIGEST, digest);
+  }
+  explicit PlasmaCreateAndSealRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaCreateAndSealRequestBuilder &operator=(const PlasmaCreateAndSealRequestBuilder &);
+  flatbuffers::Offset<PlasmaCreateAndSealRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaCreateAndSealRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    bool evict_if_full = false,
+    flatbuffers::Offset<flatbuffers::String> data = 0,
+    flatbuffers::Offset<flatbuffers::String> metadata = 0,
+    flatbuffers::Offset<flatbuffers::String> digest = 0) {
+  PlasmaCreateAndSealRequestBuilder builder_(_fbb);
+  builder_.add_digest(digest);
+  builder_.add_metadata(metadata);
+  builder_.add_data(data);
+  builder_.add_object_id(object_id);
+  builder_.add_evict_if_full(evict_if_full);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    bool evict_if_full = false,
+    const char *data = nullptr,
+    const char *metadata = nullptr,
+    const char *digest = nullptr) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  auto data__ = data ? _fbb.CreateString(data) : 0;
+  auto metadata__ = metadata ? _fbb.CreateString(metadata) : 0;
+  auto digest__ = digest ? _fbb.CreateString(digest) : 0;
+  return plasma::flatbuf::CreatePlasmaCreateAndSealRequest(
+      _fbb,
+      object_id__,
+      evict_if_full,
+      data__,
+      metadata__,
+      digest__);
+}
+
+flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaCreateAndSealReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaCreateAndSealReply TableType;
+  plasma::flatbuf::PlasmaError error;
+  PlasmaCreateAndSealReplyT()
+      : error(plasma::flatbuf::PlasmaError::OK) {
+  }
+};
+
+struct PlasmaCreateAndSealReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaCreateAndSealReplyT NativeTableType;
+  typedef PlasmaCreateAndSealReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ERROR = 4
+  };
+  plasma::flatbuf::PlasmaError error() const {
+    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_ERROR) &&
+           verifier.EndTable();
+  }
+  PlasmaCreateAndSealReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaCreateAndSealReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaCreateAndSealReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaCreateAndSealReplyBuilder {
+  typedef PlasmaCreateAndSealReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_error(plasma::flatbuf::PlasmaError error) {
+    fbb_.AddElement<int32_t>(PlasmaCreateAndSealReply::VT_ERROR, static_cast<int32_t>(error), 0);
+  }
+  explicit PlasmaCreateAndSealReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaCreateAndSealReplyBuilder &operator=(const PlasmaCreateAndSealReplyBuilder &);
+  flatbuffers::Offset<PlasmaCreateAndSealReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaCreateAndSealReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
+  PlasmaCreateAndSealReplyBuilder builder_(_fbb);
+  builder_.add_error(error);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaCreateAndSealBatchRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaCreateAndSealBatchRequest TableType;
+  std::vector<std::string> object_ids;
+  bool evict_if_full;
+  std::vector<std::string> data;
+  std::vector<std::string> metadata;
+  std::vector<std::string> digest;
+  PlasmaCreateAndSealBatchRequestT()
+      : evict_if_full(false) {
+  }
+};
+
+struct PlasmaCreateAndSealBatchRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaCreateAndSealBatchRequestT NativeTableType;
+  typedef PlasmaCreateAndSealBatchRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_IDS = 4,
+    VT_EVICT_IF_FULL = 6,
+    VT_DATA = 8,
+    VT_METADATA = 10,
+    VT_DIGEST = 12
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
+  }
+  bool evict_if_full() const {
+    return GetField<uint8_t>(VT_EVICT_IF_FULL, 0) != 0;
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *data() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DATA);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *metadata() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_METADATA);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *digest() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DIGEST);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_IDS) &&
+           verifier.VerifyVector(object_ids()) &&
+           verifier.VerifyVectorOfStrings(object_ids()) &&
+           VerifyField<uint8_t>(verifier, VT_EVICT_IF_FULL) &&
+           VerifyOffset(verifier, VT_DATA) &&
+           verifier.VerifyVector(data()) &&
+           verifier.VerifyVectorOfStrings(data()) &&
+           VerifyOffset(verifier, VT_METADATA) &&
+           verifier.VerifyVector(metadata()) &&
+           verifier.VerifyVectorOfStrings(metadata()) &&
+           VerifyOffset(verifier, VT_DIGEST) &&
+           verifier.VerifyVector(digest()) &&
+           verifier.VerifyVectorOfStrings(digest()) &&
+           verifier.EndTable();
+  }
+  PlasmaCreateAndSealBatchRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaCreateAndSealBatchRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaCreateAndSealBatchRequestBuilder {
+  typedef PlasmaCreateAndSealBatchRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
+    fbb_.AddOffset(PlasmaCreateAndSealBatchRequest::VT_OBJECT_IDS, object_ids);
+  }
+  void add_evict_if_full(bool evict_if_full) {
+    fbb_.AddElement<uint8_t>(PlasmaCreateAndSealBatchRequest::VT_EVICT_IF_FULL, static_cast<uint8_t>(evict_if_full), 0);
+  }
+  void add_data(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> data) {
+    fbb_.AddOffset(PlasmaCreateAndSealBatchRequest::VT_DATA, data);
+  }
+  void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> metadata) {
+    fbb_.AddOffset(PlasmaCreateAndSealBatchRequest::VT_METADATA, metadata);
+  }
+  void add_digest(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> digest) {
+    fbb_.AddOffset(PlasmaCreateAndSealBatchRequest::VT_DIGEST, digest);
+  }
+  explicit PlasmaCreateAndSealBatchRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaCreateAndSealBatchRequestBuilder &operator=(const PlasmaCreateAndSealBatchRequestBuilder &);
+  flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaCreateAndSealBatchRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBatchRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0,
+    bool evict_if_full = false,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> data = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> metadata = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> digest = 0) {
+  PlasmaCreateAndSealBatchRequestBuilder builder_(_fbb);
+  builder_.add_digest(digest);
+  builder_.add_metadata(metadata);
+  builder_.add_data(data);
+  builder_.add_object_ids(object_ids);
+  builder_.add_evict_if_full(evict_if_full);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBatchRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr,
+    bool evict_if_full = false,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *data = nullptr,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *metadata = nullptr,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *digest = nullptr) {
+  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
+  auto data__ = data ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*data) : 0;
+  auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*metadata) : 0;
+  auto digest__ = digest ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*digest) : 0;
+  return plasma::flatbuf::CreatePlasmaCreateAndSealBatchRequest(
+      _fbb,
+      object_ids__,
+      evict_if_full,
+      data__,
+      metadata__,
+      digest__);
+}
+
+flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBatchRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaCreateAndSealBatchReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaCreateAndSealBatchReply TableType;
+  plasma::flatbuf::PlasmaError error;
+  PlasmaCreateAndSealBatchReplyT()
+      : error(plasma::flatbuf::PlasmaError::OK) {
+  }
+};
+
+struct PlasmaCreateAndSealBatchReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaCreateAndSealBatchReplyT NativeTableType;
+  typedef PlasmaCreateAndSealBatchReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ERROR = 4
+  };
+  plasma::flatbuf::PlasmaError error() const {
+    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_ERROR) &&
+           verifier.EndTable();
+  }
+  PlasmaCreateAndSealBatchReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaCreateAndSealBatchReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaCreateAndSealBatchReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaCreateAndSealBatchReplyBuilder {
+  typedef PlasmaCreateAndSealBatchReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_error(plasma::flatbuf::PlasmaError error) {
+    fbb_.AddElement<int32_t>(PlasmaCreateAndSealBatchReply::VT_ERROR, static_cast<int32_t>(error), 0);
+  }
+  explicit PlasmaCreateAndSealBatchReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaCreateAndSealBatchReplyBuilder &operator=(const PlasmaCreateAndSealBatchReplyBuilder &);
+  flatbuffers::Offset<PlasmaCreateAndSealBatchReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaCreateAndSealBatchReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndSealBatchReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
+  PlasmaCreateAndSealBatchReplyBuilder builder_(_fbb);
+  builder_.add_error(error);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndSealBatchReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaAbortRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaAbortRequest TableType;
+  std::string object_id;
+  PlasmaAbortRequestT() {
+  }
+};
+
+struct PlasmaAbortRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaAbortRequestT NativeTableType;
+  typedef PlasmaAbortRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           verifier.EndTable();
+  }
+  PlasmaAbortRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaAbortRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaAbortRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaAbortRequestBuilder {
+  typedef PlasmaAbortRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaAbortRequest::VT_OBJECT_ID, object_id);
+  }
+  explicit PlasmaAbortRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaAbortRequestBuilder &operator=(const PlasmaAbortRequestBuilder &);
+  flatbuffers::Offset<PlasmaAbortRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaAbortRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0) {
+  PlasmaAbortRequestBuilder builder_(_fbb);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaAbortRequest(
+      _fbb,
+      object_id__);
+}
+
+flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaAbortReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaAbortReply TableType;
+  std::string object_id;
+  PlasmaAbortReplyT() {
+  }
+};
+
+struct PlasmaAbortReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaAbortReplyT NativeTableType;
+  typedef PlasmaAbortReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           verifier.EndTable();
+  }
+  PlasmaAbortReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaAbortReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaAbortReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaAbortReplyBuilder {
+  typedef PlasmaAbortReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaAbortReply::VT_OBJECT_ID, object_id);
+  }
+  explicit PlasmaAbortReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaAbortReplyBuilder &operator=(const PlasmaAbortReplyBuilder &);
+  flatbuffers::Offset<PlasmaAbortReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaAbortReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0) {
+  PlasmaAbortReplyBuilder builder_(_fbb);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaAbortReply(
+      _fbb,
+      object_id__);
+}
+
+flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaSealRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaSealRequest TableType;
+  std::string object_id;
+  std::string digest;
+  PlasmaSealRequestT() {
+  }
+};
+
+struct PlasmaSealRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaSealRequestT NativeTableType;
+  typedef PlasmaSealRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_DIGEST = 6
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  const flatbuffers::String *digest() const {
+    return GetPointer<const flatbuffers::String *>(VT_DIGEST);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyOffset(verifier, VT_DIGEST) &&
+           verifier.VerifyString(digest()) &&
+           verifier.EndTable();
+  }
+  PlasmaSealRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaSealRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaSealRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaSealRequestBuilder {
+  typedef PlasmaSealRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaSealRequest::VT_OBJECT_ID, object_id);
+  }
+  void add_digest(flatbuffers::Offset<flatbuffers::String> digest) {
+    fbb_.AddOffset(PlasmaSealRequest::VT_DIGEST, digest);
+  }
+  explicit PlasmaSealRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaSealRequestBuilder &operator=(const PlasmaSealRequestBuilder &);
+  flatbuffers::Offset<PlasmaSealRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaSealRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    flatbuffers::Offset<flatbuffers::String> digest = 0) {
+  PlasmaSealRequestBuilder builder_(_fbb);
+  builder_.add_digest(digest);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    const char *digest = nullptr) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  auto digest__ = digest ? _fbb.CreateString(digest) : 0;
+  return plasma::flatbuf::CreatePlasmaSealRequest(
+      _fbb,
+      object_id__,
+      digest__);
+}
+
+flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaSealReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaSealReply TableType;
+  std::string object_id;
+  plasma::flatbuf::PlasmaError error;
+  PlasmaSealReplyT()
+      : error(plasma::flatbuf::PlasmaError::OK) {
+  }
+};
+
+struct PlasmaSealReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaSealReplyT NativeTableType;
+  typedef PlasmaSealReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_ERROR = 6
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  plasma::flatbuf::PlasmaError error() const {
+    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyField<int32_t>(verifier, VT_ERROR) &&
+           verifier.EndTable();
+  }
+  PlasmaSealReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaSealReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaSealReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaSealReplyBuilder {
+  typedef PlasmaSealReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaSealReply::VT_OBJECT_ID, object_id);
+  }
+  void add_error(plasma::flatbuf::PlasmaError error) {
+    fbb_.AddElement<int32_t>(PlasmaSealReply::VT_ERROR, static_cast<int32_t>(error), 0);
+  }
+  explicit PlasmaSealReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaSealReplyBuilder &operator=(const PlasmaSealReplyBuilder &);
+  flatbuffers::Offset<PlasmaSealReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaSealReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
+  PlasmaSealReplyBuilder builder_(_fbb);
+  builder_.add_error(error);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaSealReply(
+      _fbb,
+      object_id__,
+      error);
+}
+
+flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaGetRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaGetRequest TableType;
+  std::vector<std::string> object_ids;
+  int64_t timeout_ms;
+  PlasmaGetRequestT()
+      : timeout_ms(0) {
+  }
+};
+
+struct PlasmaGetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaGetRequestT NativeTableType;
+  typedef PlasmaGetRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_IDS = 4,
+    VT_TIMEOUT_MS = 6
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
+  }
+  int64_t timeout_ms() const {
+    return GetField<int64_t>(VT_TIMEOUT_MS, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_IDS) &&
+           verifier.VerifyVector(object_ids()) &&
+           verifier.VerifyVectorOfStrings(object_ids()) &&
+           VerifyField<int64_t>(verifier, VT_TIMEOUT_MS) &&
+           verifier.EndTable();
+  }
+  PlasmaGetRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaGetRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaGetRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaGetRequestBuilder {
+  typedef PlasmaGetRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
+    fbb_.AddOffset(PlasmaGetRequest::VT_OBJECT_IDS, object_ids);
+  }
+  void add_timeout_ms(int64_t timeout_ms) {
+    fbb_.AddElement<int64_t>(PlasmaGetRequest::VT_TIMEOUT_MS, timeout_ms, 0);
+  }
+  explicit PlasmaGetRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaGetRequestBuilder &operator=(const PlasmaGetRequestBuilder &);
+  flatbuffers::Offset<PlasmaGetRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaGetRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0,
+    int64_t timeout_ms = 0) {
+  PlasmaGetRequestBuilder builder_(_fbb);
+  builder_.add_timeout_ms(timeout_ms);
+  builder_.add_object_ids(object_ids);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr,
+    int64_t timeout_ms = 0) {
+  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
+  return plasma::flatbuf::CreatePlasmaGetRequest(
+      _fbb,
+      object_ids__,
+      timeout_ms);
+}
+
+flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaGetReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaGetReply TableType;
+  std::vector<std::string> object_ids;
+  std::vector<plasma::flatbuf::PlasmaObjectSpec> plasma_objects;
+  std::vector<int32_t> store_fds;
+  std::vector<int64_t> mmap_sizes;
+  std::vector<std::unique_ptr<plasma::flatbuf::CudaHandleT>> handles;
+  PlasmaGetReplyT() {
+  }
+};
+
+struct PlasmaGetReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaGetReplyT NativeTableType;
+  typedef PlasmaGetReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_IDS = 4,
+    VT_PLASMA_OBJECTS = 6,
+    VT_STORE_FDS = 8,
+    VT_MMAP_SIZES = 10,
+    VT_HANDLES = 12
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
+  }
+  const flatbuffers::Vector<const plasma::flatbuf::PlasmaObjectSpec *> *plasma_objects() const {
+    return GetPointer<const flatbuffers::Vector<const plasma::flatbuf::PlasmaObjectSpec *> *>(VT_PLASMA_OBJECTS);
+  }
+  const flatbuffers::Vector<int32_t> *store_fds() const {
+    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STORE_FDS);
+  }
+  const flatbuffers::Vector<int64_t> *mmap_sizes() const {
+    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_MMAP_SIZES);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>> *handles() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>> *>(VT_HANDLES);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_IDS) &&
+           verifier.VerifyVector(object_ids()) &&
+           verifier.VerifyVectorOfStrings(object_ids()) &&
+           VerifyOffset(verifier, VT_PLASMA_OBJECTS) &&
+           verifier.VerifyVector(plasma_objects()) &&
+           VerifyOffset(verifier, VT_STORE_FDS) &&
+           verifier.VerifyVector(store_fds()) &&
+           VerifyOffset(verifier, VT_MMAP_SIZES) &&
+           verifier.VerifyVector(mmap_sizes()) &&
+           VerifyOffset(verifier, VT_HANDLES) &&
+           verifier.VerifyVector(handles()) &&
+           verifier.VerifyVectorOfTables(handles()) &&
+           verifier.EndTable();
+  }
+  PlasmaGetReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaGetReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaGetReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaGetReplyBuilder {
+  typedef PlasmaGetReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
+    fbb_.AddOffset(PlasmaGetReply::VT_OBJECT_IDS, object_ids);
+  }
+  void add_plasma_objects(flatbuffers::Offset<flatbuffers::Vector<const plasma::flatbuf::PlasmaObjectSpec *>> plasma_objects) {
+    fbb_.AddOffset(PlasmaGetReply::VT_PLASMA_OBJECTS, plasma_objects);
+  }
+  void add_store_fds(flatbuffers::Offset<flatbuffers::Vector<int32_t>> store_fds) {
+    fbb_.AddOffset(PlasmaGetReply::VT_STORE_FDS, store_fds);
+  }
+  void add_mmap_sizes(flatbuffers::Offset<flatbuffers::Vector<int64_t>> mmap_sizes) {
+    fbb_.AddOffset(PlasmaGetReply::VT_MMAP_SIZES, mmap_sizes);
+  }
+  void add_handles(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>>> handles) {
+    fbb_.AddOffset(PlasmaGetReply::VT_HANDLES, handles);
+  }
+  explicit PlasmaGetReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaGetReplyBuilder &operator=(const PlasmaGetReplyBuilder &);
+  flatbuffers::Offset<PlasmaGetReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaGetReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0,
+    flatbuffers::Offset<flatbuffers::Vector<const plasma::flatbuf::PlasmaObjectSpec *>> plasma_objects = 0,
+    flatbuffers::Offset<flatbuffers::Vector<int32_t>> store_fds = 0,
+    flatbuffers::Offset<flatbuffers::Vector<int64_t>> mmap_sizes = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>>> handles = 0) {
+  PlasmaGetReplyBuilder builder_(_fbb);
+  builder_.add_handles(handles);
+  builder_.add_mmap_sizes(mmap_sizes);
+  builder_.add_store_fds(store_fds);
+  builder_.add_plasma_objects(plasma_objects);
+  builder_.add_object_ids(object_ids);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr,
+    const std::vector<plasma::flatbuf::PlasmaObjectSpec> *plasma_objects = nullptr,
+    const std::vector<int32_t> *store_fds = nullptr,
+    const std::vector<int64_t> *mmap_sizes = nullptr,
+    const std::vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>> *handles = nullptr) {
+  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
+  auto plasma_objects__ = plasma_objects ? _fbb.CreateVectorOfStructs<plasma::flatbuf::PlasmaObjectSpec>(*plasma_objects) : 0;
+  auto store_fds__ = store_fds ? _fbb.CreateVector<int32_t>(*store_fds) : 0;
+  auto mmap_sizes__ = mmap_sizes ? _fbb.CreateVector<int64_t>(*mmap_sizes) : 0;
+  auto handles__ = handles ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>>(*handles) : 0;
+  return plasma::flatbuf::CreatePlasmaGetReply(
+      _fbb,
+      object_ids__,
+      plasma_objects__,
+      store_fds__,
+      mmap_sizes__,
+      handles__);
+}
+
+flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaReleaseRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaReleaseRequest TableType;
+  std::string object_id;
+  PlasmaReleaseRequestT() {
+  }
+};
+
+struct PlasmaReleaseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaReleaseRequestT NativeTableType;
+  typedef PlasmaReleaseRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           verifier.EndTable();
+  }
+  PlasmaReleaseRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaReleaseRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaReleaseRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaReleaseRequestBuilder {
+  typedef PlasmaReleaseRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaReleaseRequest::VT_OBJECT_ID, object_id);
+  }
+  explicit PlasmaReleaseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaReleaseRequestBuilder &operator=(const PlasmaReleaseRequestBuilder &);
+  flatbuffers::Offset<PlasmaReleaseRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaReleaseRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0) {
+  PlasmaReleaseRequestBuilder builder_(_fbb);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaReleaseRequest(
+      _fbb,
+      object_id__);
+}
+
+flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaReleaseReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaReleaseReply TableType;
+  std::string object_id;
+  plasma::flatbuf::PlasmaError error;
+  PlasmaReleaseReplyT()
+      : error(plasma::flatbuf::PlasmaError::OK) {
+  }
+};
+
+struct PlasmaReleaseReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaReleaseReplyT NativeTableType;
+  typedef PlasmaReleaseReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_ERROR = 6
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  plasma::flatbuf::PlasmaError error() const {
+    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyField<int32_t>(verifier, VT_ERROR) &&
+           verifier.EndTable();
+  }
+  PlasmaReleaseReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaReleaseReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaReleaseReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaReleaseReplyBuilder {
+  typedef PlasmaReleaseReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaReleaseReply::VT_OBJECT_ID, object_id);
+  }
+  void add_error(plasma::flatbuf::PlasmaError error) {
+    fbb_.AddElement<int32_t>(PlasmaReleaseReply::VT_ERROR, static_cast<int32_t>(error), 0);
+  }
+  explicit PlasmaReleaseReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaReleaseReplyBuilder &operator=(const PlasmaReleaseReplyBuilder &);
+  flatbuffers::Offset<PlasmaReleaseReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaReleaseReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
+  PlasmaReleaseReplyBuilder builder_(_fbb);
+  builder_.add_error(error);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaReleaseReply(
+      _fbb,
+      object_id__,
+      error);
+}
+
+flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaDeleteRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaDeleteRequest TableType;
+  int32_t count;
+  std::vector<std::string> object_ids;
+  PlasmaDeleteRequestT()
+      : count(0) {
+  }
+};
+
+struct PlasmaDeleteRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaDeleteRequestT NativeTableType;
+  typedef PlasmaDeleteRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_COUNT = 4,
+    VT_OBJECT_IDS = 6
+  };
+  int32_t count() const {
+    return GetField<int32_t>(VT_COUNT, 0);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_COUNT) &&
+           VerifyOffset(verifier, VT_OBJECT_IDS) &&
+           verifier.VerifyVector(object_ids()) &&
+           verifier.VerifyVectorOfStrings(object_ids()) &&
+           verifier.EndTable();
+  }
+  PlasmaDeleteRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaDeleteRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaDeleteRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaDeleteRequestBuilder {
+  typedef PlasmaDeleteRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_count(int32_t count) {
+    fbb_.AddElement<int32_t>(PlasmaDeleteRequest::VT_COUNT, count, 0);
+  }
+  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
+    fbb_.AddOffset(PlasmaDeleteRequest::VT_OBJECT_IDS, object_ids);
+  }
+  explicit PlasmaDeleteRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaDeleteRequestBuilder &operator=(const PlasmaDeleteRequestBuilder &);
+  flatbuffers::Offset<PlasmaDeleteRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaDeleteRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t count = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0) {
+  PlasmaDeleteRequestBuilder builder_(_fbb);
+  builder_.add_object_ids(object_ids);
+  builder_.add_count(count);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t count = 0,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr) {
+  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
+  return plasma::flatbuf::CreatePlasmaDeleteRequest(
+      _fbb,
+      count,
+      object_ids__);
+}
+
+flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaDeleteReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaDeleteReply TableType;
+  int32_t count;
+  std::vector<std::string> object_ids;
+  std::vector<plasma::flatbuf::PlasmaError> errors;
+  PlasmaDeleteReplyT()
+      : count(0) {
+  }
+};
+
+struct PlasmaDeleteReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaDeleteReplyT NativeTableType;
+  typedef PlasmaDeleteReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_COUNT = 4,
+    VT_OBJECT_IDS = 6,
+    VT_ERRORS = 8
+  };
+  int32_t count() const {
+    return GetField<int32_t>(VT_COUNT, 0);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
+  }
+  const flatbuffers::Vector<int32_t> *errors() const {
+    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_ERRORS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_COUNT) &&
+           VerifyOffset(verifier, VT_OBJECT_IDS) &&
+           verifier.VerifyVector(object_ids()) &&
+           verifier.VerifyVectorOfStrings(object_ids()) &&
+           VerifyOffset(verifier, VT_ERRORS) &&
+           verifier.VerifyVector(errors()) &&
+           verifier.EndTable();
+  }
+  PlasmaDeleteReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaDeleteReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaDeleteReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaDeleteReplyBuilder {
+  typedef PlasmaDeleteReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_count(int32_t count) {
+    fbb_.AddElement<int32_t>(PlasmaDeleteReply::VT_COUNT, count, 0);
+  }
+  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
+    fbb_.AddOffset(PlasmaDeleteReply::VT_OBJECT_IDS, object_ids);
+  }
+  void add_errors(flatbuffers::Offset<flatbuffers::Vector<int32_t>> errors) {
+    fbb_.AddOffset(PlasmaDeleteReply::VT_ERRORS, errors);
+  }
+  explicit PlasmaDeleteReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaDeleteReplyBuilder &operator=(const PlasmaDeleteReplyBuilder &);
+  flatbuffers::Offset<PlasmaDeleteReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaDeleteReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t count = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0,
+    flatbuffers::Offset<flatbuffers::Vector<int32_t>> errors = 0) {
+  PlasmaDeleteReplyBuilder builder_(_fbb);
+  builder_.add_errors(errors);
+  builder_.add_object_ids(object_ids);
+  builder_.add_count(count);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t count = 0,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr,
+    const std::vector<int32_t> *errors = nullptr) {
+  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
+  auto errors__ = errors ? _fbb.CreateVector<int32_t>(*errors) : 0;
+  return plasma::flatbuf::CreatePlasmaDeleteReply(
+      _fbb,
+      count,
+      object_ids__,
+      errors__);
+}
+
+flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaContainsRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaContainsRequest TableType;
+  std::string object_id;
+  PlasmaContainsRequestT() {
+  }
+};
+
+struct PlasmaContainsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaContainsRequestT NativeTableType;
+  typedef PlasmaContainsRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           verifier.EndTable();
+  }
+  PlasmaContainsRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaContainsRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaContainsRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaContainsRequestBuilder {
+  typedef PlasmaContainsRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaContainsRequest::VT_OBJECT_ID, object_id);
+  }
+  explicit PlasmaContainsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaContainsRequestBuilder &operator=(const PlasmaContainsRequestBuilder &);
+  flatbuffers::Offset<PlasmaContainsRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaContainsRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0) {
+  PlasmaContainsRequestBuilder builder_(_fbb);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaContainsRequest(
+      _fbb,
+      object_id__);
+}
+
+flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaContainsReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaContainsReply TableType;
+  std::string object_id;
+  int32_t has_object;
+  PlasmaContainsReplyT()
+      : has_object(0) {
+  }
+};
+
+struct PlasmaContainsReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaContainsReplyT NativeTableType;
+  typedef PlasmaContainsReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_HAS_OBJECT = 6
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  int32_t has_object() const {
+    return GetField<int32_t>(VT_HAS_OBJECT, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyField<int32_t>(verifier, VT_HAS_OBJECT) &&
+           verifier.EndTable();
+  }
+  PlasmaContainsReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaContainsReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaContainsReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaContainsReplyBuilder {
+  typedef PlasmaContainsReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaContainsReply::VT_OBJECT_ID, object_id);
+  }
+  void add_has_object(int32_t has_object) {
+    fbb_.AddElement<int32_t>(PlasmaContainsReply::VT_HAS_OBJECT, has_object, 0);
+  }
+  explicit PlasmaContainsReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaContainsReplyBuilder &operator=(const PlasmaContainsReplyBuilder &);
+  flatbuffers::Offset<PlasmaContainsReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaContainsReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    int32_t has_object = 0) {
+  PlasmaContainsReplyBuilder builder_(_fbb);
+  builder_.add_has_object(has_object);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    int32_t has_object = 0) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaContainsReply(
+      _fbb,
+      object_id__,
+      has_object);
+}
+
+flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaListRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaListRequest TableType;
+  PlasmaListRequestT() {
+  }
+};
+
+struct PlasmaListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaListRequestT NativeTableType;
+  typedef PlasmaListRequestBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+  PlasmaListRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaListRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaListRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaListRequestBuilder {
+  typedef PlasmaListRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit PlasmaListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaListRequestBuilder &operator=(const PlasmaListRequestBuilder &);
+  flatbuffers::Offset<PlasmaListRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaListRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  PlasmaListRequestBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaListReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaListReply TableType;
+  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> objects;
+  PlasmaListReplyT() {
+  }
+};
+
+struct PlasmaListReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaListReplyT NativeTableType;
+  typedef PlasmaListReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECTS = 4
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *objects() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *>(VT_OBJECTS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECTS) &&
+           verifier.VerifyVector(objects()) &&
+           verifier.VerifyVectorOfTables(objects()) &&
+           verifier.EndTable();
+  }
+  PlasmaListReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaListReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaListReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaListReplyBuilder {
+  typedef PlasmaListReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>> objects) {
+    fbb_.AddOffset(PlasmaListReply::VT_OBJECTS, objects);
+  }
+  explicit PlasmaListReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaListReplyBuilder &operator=(const PlasmaListReplyBuilder &);
+  flatbuffers::Offset<PlasmaListReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaListReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>> objects = 0) {
+  PlasmaListReplyBuilder builder_(_fbb);
+  builder_.add_objects(objects);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *objects = nullptr) {
+  auto objects__ = objects ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>(*objects) : 0;
+  return plasma::flatbuf::CreatePlasmaListReply(
+      _fbb,
+      objects__);
+}
+
+flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaConnectRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaConnectRequest TableType;
+  PlasmaConnectRequestT() {
+  }
+};
+
+struct PlasmaConnectRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaConnectRequestT NativeTableType;
+  typedef PlasmaConnectRequestBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+  PlasmaConnectRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaConnectRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaConnectRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaConnectRequestBuilder {
+  typedef PlasmaConnectRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit PlasmaConnectRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaConnectRequestBuilder &operator=(const PlasmaConnectRequestBuilder &);
+  flatbuffers::Offset<PlasmaConnectRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaConnectRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  PlasmaConnectRequestBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaConnectReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaConnectReply TableType;
+  int64_t memory_capacity;
+  PlasmaConnectReplyT()
+      : memory_capacity(0) {
+  }
+};
+
+struct PlasmaConnectReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaConnectReplyT NativeTableType;
+  typedef PlasmaConnectReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_MEMORY_CAPACITY = 4
+  };
+  int64_t memory_capacity() const {
+    return GetField<int64_t>(VT_MEMORY_CAPACITY, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int64_t>(verifier, VT_MEMORY_CAPACITY) &&
+           verifier.EndTable();
+  }
+  PlasmaConnectReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaConnectReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaConnectReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaConnectReplyBuilder {
+  typedef PlasmaConnectReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_memory_capacity(int64_t memory_capacity) {
+    fbb_.AddElement<int64_t>(PlasmaConnectReply::VT_MEMORY_CAPACITY, memory_capacity, 0);
+  }
+  explicit PlasmaConnectReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaConnectReplyBuilder &operator=(const PlasmaConnectReplyBuilder &);
+  flatbuffers::Offset<PlasmaConnectReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaConnectReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t memory_capacity = 0) {
+  PlasmaConnectReplyBuilder builder_(_fbb);
+  builder_.add_memory_capacity(memory_capacity);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaEvictRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaEvictRequest TableType;
+  uint64_t num_bytes;
+  PlasmaEvictRequestT()
+      : num_bytes(0) {
+  }
+};
+
+struct PlasmaEvictRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaEvictRequestT NativeTableType;
+  typedef PlasmaEvictRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NUM_BYTES = 4
+  };
+  uint64_t num_bytes() const {
+    return GetField<uint64_t>(VT_NUM_BYTES, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint64_t>(verifier, VT_NUM_BYTES) &&
+           verifier.EndTable();
+  }
+  PlasmaEvictRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaEvictRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaEvictRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaEvictRequestBuilder {
+  typedef PlasmaEvictRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_num_bytes(uint64_t num_bytes) {
+    fbb_.AddElement<uint64_t>(PlasmaEvictRequest::VT_NUM_BYTES, num_bytes, 0);
+  }
+  explicit PlasmaEvictRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaEvictRequestBuilder &operator=(const PlasmaEvictRequestBuilder &);
+  flatbuffers::Offset<PlasmaEvictRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaEvictRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t num_bytes = 0) {
+  PlasmaEvictRequestBuilder builder_(_fbb);
+  builder_.add_num_bytes(num_bytes);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaEvictReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaEvictReply TableType;
+  uint64_t num_bytes;
+  PlasmaEvictReplyT()
+      : num_bytes(0) {
+  }
+};
+
+struct PlasmaEvictReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaEvictReplyT NativeTableType;
+  typedef PlasmaEvictReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NUM_BYTES = 4
+  };
+  uint64_t num_bytes() const {
+    return GetField<uint64_t>(VT_NUM_BYTES, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint64_t>(verifier, VT_NUM_BYTES) &&
+           verifier.EndTable();
+  }
+  PlasmaEvictReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaEvictReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaEvictReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaEvictReplyBuilder {
+  typedef PlasmaEvictReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_num_bytes(uint64_t num_bytes) {
+    fbb_.AddElement<uint64_t>(PlasmaEvictReply::VT_NUM_BYTES, num_bytes, 0);
+  }
+  explicit PlasmaEvictReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaEvictReplyBuilder &operator=(const PlasmaEvictReplyBuilder &);
+  flatbuffers::Offset<PlasmaEvictReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaEvictReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t num_bytes = 0) {
+  PlasmaEvictReplyBuilder builder_(_fbb);
+  builder_.add_num_bytes(num_bytes);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaSubscribeRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaSubscribeRequest TableType;
+  PlasmaSubscribeRequestT() {
+  }
+};
+
+struct PlasmaSubscribeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaSubscribeRequestT NativeTableType;
+  typedef PlasmaSubscribeRequestBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+  PlasmaSubscribeRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaSubscribeRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaSubscribeRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSubscribeRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaSubscribeRequestBuilder {
+  typedef PlasmaSubscribeRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit PlasmaSubscribeRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaSubscribeRequestBuilder &operator=(const PlasmaSubscribeRequestBuilder &);
+  flatbuffers::Offset<PlasmaSubscribeRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaSubscribeRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  PlasmaSubscribeRequestBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSubscribeRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaNotificationT : public flatbuffers::NativeTable {
+  typedef PlasmaNotification TableType;
+  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> object_info;
+  PlasmaNotificationT() {
+  }
+};
+
+struct PlasmaNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaNotificationT NativeTableType;
+  typedef PlasmaNotificationBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_INFO = 4
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *object_info() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *>(VT_OBJECT_INFO);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_INFO) &&
+           verifier.VerifyVector(object_info()) &&
+           verifier.VerifyVectorOfTables(object_info()) &&
+           verifier.EndTable();
+  }
+  PlasmaNotificationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaNotificationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaNotification> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaNotificationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaNotificationBuilder {
+  typedef PlasmaNotification Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_info(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>> object_info) {
+    fbb_.AddOffset(PlasmaNotification::VT_OBJECT_INFO, object_info);
+  }
+  explicit PlasmaNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaNotificationBuilder &operator=(const PlasmaNotificationBuilder &);
+  flatbuffers::Offset<PlasmaNotification> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaNotification>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>> object_info = 0) {
+  PlasmaNotificationBuilder builder_(_fbb);
+  builder_.add_object_info(object_info);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotificationDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *object_info = nullptr) {
+  auto object_info__ = object_info ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>(*object_info) : 0;
+  return plasma::flatbuf::CreatePlasmaNotification(
+      _fbb,
+      object_info__);
+}
+
+flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaNotificationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaDataRequestT : public flatbuffers::NativeTable {
+  typedef PlasmaDataRequest TableType;
+  std::string object_id;
+  std::string address;
+  int32_t port;
+  PlasmaDataRequestT()
+      : port(0) {
+  }
+};
+
+struct PlasmaDataRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaDataRequestT NativeTableType;
+  typedef PlasmaDataRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_ADDRESS = 6,
+    VT_PORT = 8
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  const flatbuffers::String *address() const {
+    return GetPointer<const flatbuffers::String *>(VT_ADDRESS);
+  }
+  int32_t port() const {
+    return GetField<int32_t>(VT_PORT, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyOffset(verifier, VT_ADDRESS) &&
+           verifier.VerifyString(address()) &&
+           VerifyField<int32_t>(verifier, VT_PORT) &&
+           verifier.EndTable();
+  }
+  PlasmaDataRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaDataRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaDataRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaDataRequestBuilder {
+  typedef PlasmaDataRequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaDataRequest::VT_OBJECT_ID, object_id);
+  }
+  void add_address(flatbuffers::Offset<flatbuffers::String> address) {
+    fbb_.AddOffset(PlasmaDataRequest::VT_ADDRESS, address);
+  }
+  void add_port(int32_t port) {
+    fbb_.AddElement<int32_t>(PlasmaDataRequest::VT_PORT, port, 0);
+  }
+  explicit PlasmaDataRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaDataRequestBuilder &operator=(const PlasmaDataRequestBuilder &);
+  flatbuffers::Offset<PlasmaDataRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaDataRequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    flatbuffers::Offset<flatbuffers::String> address = 0,
+    int32_t port = 0) {
+  PlasmaDataRequestBuilder builder_(_fbb);
+  builder_.add_port(port);
+  builder_.add_address(address);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    const char *address = nullptr,
+    int32_t port = 0) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  auto address__ = address ? _fbb.CreateString(address) : 0;
+  return plasma::flatbuf::CreatePlasmaDataRequest(
+      _fbb,
+      object_id__,
+      address__,
+      port);
+}
+
+flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaDataReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaDataReply TableType;
+  std::string object_id;
+  uint64_t object_size;
+  uint64_t metadata_size;
+  PlasmaDataReplyT()
+      : object_size(0),
+        metadata_size(0) {
+  }
+};
+
+struct PlasmaDataReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaDataReplyT NativeTableType;
+  typedef PlasmaDataReplyBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_ID = 4,
+    VT_OBJECT_SIZE = 6,
+    VT_METADATA_SIZE = 8
+  };
+  const flatbuffers::String *object_id() const {
+    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
+  }
+  uint64_t object_size() const {
+    return GetField<uint64_t>(VT_OBJECT_SIZE, 0);
+  }
+  uint64_t metadata_size() const {
+    return GetField<uint64_t>(VT_METADATA_SIZE, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_ID) &&
+           verifier.VerifyString(object_id()) &&
+           VerifyField<uint64_t>(verifier, VT_OBJECT_SIZE) &&
+           VerifyField<uint64_t>(verifier, VT_METADATA_SIZE) &&
+           verifier.EndTable();
+  }
+  PlasmaDataReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaDataReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaDataReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaDataReplyBuilder {
+  typedef PlasmaDataReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
+    fbb_.AddOffset(PlasmaDataReply::VT_OBJECT_ID, object_id);
+  }
+  void add_object_size(uint64_t object_size) {
+    fbb_.AddElement<uint64_t>(PlasmaDataReply::VT_OBJECT_SIZE, object_size, 0);
+  }
+  void add_metadata_size(uint64_t metadata_size) {
+    fbb_.AddElement<uint64_t>(PlasmaDataReply::VT_METADATA_SIZE, metadata_size, 0);
+  }
+  explicit PlasmaDataReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaDataReplyBuilder &operator=(const PlasmaDataReplyBuilder &);
+  flatbuffers::Offset<PlasmaDataReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaDataReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> object_id = 0,
+    uint64_t object_size = 0,
+    uint64_t metadata_size = 0) {
+  PlasmaDataReplyBuilder builder_(_fbb);
+  builder_.add_metadata_size(metadata_size);
+  builder_.add_object_size(object_size);
+  builder_.add_object_id(object_id);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReplyDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *object_id = nullptr,
+    uint64_t object_size = 0,
+    uint64_t metadata_size = 0) {
+  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
+  return plasma::flatbuf::CreatePlasmaDataReply(
+      _fbb,
+      object_id__,
+      object_size,
+      metadata_size);
+}
+
+flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaRefreshLRURequestT : public flatbuffers::NativeTable {
+  typedef PlasmaRefreshLRURequest TableType;
+  std::vector<std::string> object_ids;
+  PlasmaRefreshLRURequestT() {
+  }
+};
+
+struct PlasmaRefreshLRURequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaRefreshLRURequestT NativeTableType;
+  typedef PlasmaRefreshLRURequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECT_IDS = 4
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_OBJECT_IDS) &&
+           verifier.VerifyVector(object_ids()) &&
+           verifier.VerifyVectorOfStrings(object_ids()) &&
+           verifier.EndTable();
+  }
+  PlasmaRefreshLRURequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaRefreshLRURequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaRefreshLRURequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRURequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaRefreshLRURequestBuilder {
+  typedef PlasmaRefreshLRURequest Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
+    fbb_.AddOffset(PlasmaRefreshLRURequest::VT_OBJECT_IDS, object_ids);
+  }
+  explicit PlasmaRefreshLRURequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaRefreshLRURequestBuilder &operator=(const PlasmaRefreshLRURequestBuilder &);
+  flatbuffers::Offset<PlasmaRefreshLRURequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaRefreshLRURequest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0) {
+  PlasmaRefreshLRURequestBuilder builder_(_fbb);
+  builder_.add_object_ids(object_ids);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr) {
+  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
+  return plasma::flatbuf::CreatePlasmaRefreshLRURequest(
+      _fbb,
+      object_ids__);
+}
+
+flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRURequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PlasmaRefreshLRUReplyT : public flatbuffers::NativeTable {
+  typedef PlasmaRefreshLRUReply TableType;
+  PlasmaRefreshLRUReplyT() {
+  }
+};
+
+struct PlasmaRefreshLRUReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PlasmaRefreshLRUReplyT NativeTableType;
+  typedef PlasmaRefreshLRUReplyBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+  PlasmaRefreshLRUReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PlasmaRefreshLRUReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<PlasmaRefreshLRUReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRUReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PlasmaRefreshLRUReplyBuilder {
+  typedef PlasmaRefreshLRUReply Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit PlasmaRefreshLRUReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PlasmaRefreshLRUReplyBuilder &operator=(const PlasmaRefreshLRUReplyBuilder &);
+  flatbuffers::Offset<PlasmaRefreshLRUReply> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PlasmaRefreshLRUReply>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PlasmaRefreshLRUReply> CreatePlasmaRefreshLRUReply(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  PlasmaRefreshLRUReplyBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<PlasmaRefreshLRUReply> CreatePlasmaRefreshLRUReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRUReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+inline PlasmaSetOptionsRequestT *PlasmaSetOptionsRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaSetOptionsRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSetOptionsRequestT>(new PlasmaSetOptionsRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaSetOptionsRequest::UnPackTo(PlasmaSetOptionsRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = client_name(); if (_e) _o->client_name = _e->str(); }
+  { auto _e = output_memory_quota(); _o->output_memory_quota = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaSetOptionsRequest> PlasmaSetOptionsRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaSetOptionsRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSetOptionsRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _client_name = _o->client_name.empty() ? 0 : _fbb.CreateString(_o->client_name);
+  auto _output_memory_quota = _o->output_memory_quota;
+  return plasma::flatbuf::CreatePlasmaSetOptionsRequest(
+      _fbb,
+      _client_name,
+      _output_memory_quota);
+}
+
+inline PlasmaSetOptionsReplyT *PlasmaSetOptionsReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaSetOptionsReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSetOptionsReplyT>(new PlasmaSetOptionsReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaSetOptionsReply::UnPackTo(PlasmaSetOptionsReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = error(); _o->error = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaSetOptionsReply> PlasmaSetOptionsReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaSetOptionsReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSetOptionsReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _error = _o->error;
+  return plasma::flatbuf::CreatePlasmaSetOptionsReply(
+      _fbb,
+      _error);
+}
+
+inline PlasmaGetDebugStringRequestT *PlasmaGetDebugStringRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaGetDebugStringRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaGetDebugStringRequestT>(new PlasmaGetDebugStringRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaGetDebugStringRequest::UnPackTo(PlasmaGetDebugStringRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+}
+
+inline flatbuffers::Offset<PlasmaGetDebugStringRequest> PlasmaGetDebugStringRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaGetDebugStringRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStringRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaGetDebugStringRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  return plasma::flatbuf::CreatePlasmaGetDebugStringRequest(
+      _fbb);
+}
+
+inline PlasmaGetDebugStringReplyT *PlasmaGetDebugStringReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaGetDebugStringReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaGetDebugStringReplyT>(new PlasmaGetDebugStringReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaGetDebugStringReply::UnPackTo(PlasmaGetDebugStringReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = debug_string(); if (_e) _o->debug_string = _e->str(); }
+}
+
+inline flatbuffers::Offset<PlasmaGetDebugStringReply> PlasmaGetDebugStringReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaGetDebugStringReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaGetDebugStringReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _debug_string = _o->debug_string.empty() ? 0 : _fbb.CreateString(_o->debug_string);
+  return plasma::flatbuf::CreatePlasmaGetDebugStringReply(
+      _fbb,
+      _debug_string);
+}
+
+inline PlasmaCreateRequestT *PlasmaCreateRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaCreateRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateRequestT>(new PlasmaCreateRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaCreateRequest::UnPackTo(PlasmaCreateRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = evict_if_full(); _o->evict_if_full = _e; }
+  { auto _e = data_size(); _o->data_size = _e; }
+  { auto _e = metadata_size(); _o->metadata_size = _e; }
+  { auto _e = device_num(); _o->device_num = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaCreateRequest> PlasmaCreateRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaCreateRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _evict_if_full = _o->evict_if_full;
+  auto _data_size = _o->data_size;
+  auto _metadata_size = _o->metadata_size;
+  auto _device_num = _o->device_num;
+  return plasma::flatbuf::CreatePlasmaCreateRequest(
+      _fbb,
+      _object_id,
+      _evict_if_full,
+      _data_size,
+      _metadata_size,
+      _device_num);
+}
+
+inline CudaHandleT *CudaHandle::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::CudaHandleT> _o = std::unique_ptr<plasma::flatbuf::CudaHandleT>(new CudaHandleT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void CudaHandle::UnPackTo(CudaHandleT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = handle(); if (_e) { _o->handle.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->handle[_i] = _e->Get(_i); } } }
+}
+
+inline flatbuffers::Offset<CudaHandle> CudaHandle::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CudaHandleT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateCudaHandle(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<CudaHandle> CreateCudaHandle(flatbuffers::FlatBufferBuilder &_fbb, const CudaHandleT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CudaHandleT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _handle = _o->handle.size() ? _fbb.CreateVector(_o->handle) : 0;
+  return plasma::flatbuf::CreateCudaHandle(
+      _fbb,
+      _handle);
+}
+
+inline PlasmaCreateReplyT *PlasmaCreateReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaCreateReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateReplyT>(new PlasmaCreateReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaCreateReply::UnPackTo(PlasmaCreateReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = plasma_object(); if (_e) _o->plasma_object = std::unique_ptr<plasma::flatbuf::PlasmaObjectSpec>(new plasma::flatbuf::PlasmaObjectSpec(*_e)); }
+  { auto _e = error(); _o->error = _e; }
+  { auto _e = store_fd(); _o->store_fd = _e; }
+  { auto _e = mmap_size(); _o->mmap_size = _e; }
+  { auto _e = ipc_handle(); if (_e) _o->ipc_handle = std::unique_ptr<plasma::flatbuf::CudaHandleT>(_e->UnPack(_resolver)); }
+}
+
+inline flatbuffers::Offset<PlasmaCreateReply> PlasmaCreateReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaCreateReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _plasma_object = _o->plasma_object ? _o->plasma_object.get() : 0;
+  auto _error = _o->error;
+  auto _store_fd = _o->store_fd;
+  auto _mmap_size = _o->mmap_size;
+  auto _ipc_handle = _o->ipc_handle ? CreateCudaHandle(_fbb, _o->ipc_handle.get(), _rehasher) : 0;
+  return plasma::flatbuf::CreatePlasmaCreateReply(
+      _fbb,
+      _object_id,
+      _plasma_object,
+      _error,
+      _store_fd,
+      _mmap_size,
+      _ipc_handle);
+}
+
+inline PlasmaCreateAndSealRequestT *PlasmaCreateAndSealRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealRequestT>(new PlasmaCreateAndSealRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaCreateAndSealRequest::UnPackTo(PlasmaCreateAndSealRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = evict_if_full(); _o->evict_if_full = _e; }
+  { auto _e = data(); if (_e) _o->data = _e->str(); }
+  { auto _e = metadata(); if (_e) _o->metadata = _e->str(); }
+  { auto _e = digest(); if (_e) _o->digest = _e->str(); }
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealRequest> PlasmaCreateAndSealRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaCreateAndSealRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateAndSealRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _evict_if_full = _o->evict_if_full;
+  auto _data = _o->data.empty() ? 0 : _fbb.CreateString(_o->data);
+  auto _metadata = _o->metadata.empty() ? 0 : _fbb.CreateString(_o->metadata);
+  auto _digest = _o->digest.empty() ? 0 : _fbb.CreateString(_o->digest);
+  return plasma::flatbuf::CreatePlasmaCreateAndSealRequest(
+      _fbb,
+      _object_id,
+      _evict_if_full,
+      _data,
+      _metadata,
+      _digest);
+}
+
+inline PlasmaCreateAndSealReplyT *PlasmaCreateAndSealReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealReplyT>(new PlasmaCreateAndSealReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaCreateAndSealReply::UnPackTo(PlasmaCreateAndSealReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = error(); _o->error = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealReply> PlasmaCreateAndSealReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaCreateAndSealReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateAndSealReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _error = _o->error;
+  return plasma::flatbuf::CreatePlasmaCreateAndSealReply(
+      _fbb,
+      _error);
+}
+
+inline PlasmaCreateAndSealBatchRequestT *PlasmaCreateAndSealBatchRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealBatchRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealBatchRequestT>(new PlasmaCreateAndSealBatchRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaCreateAndSealBatchRequest::UnPackTo(PlasmaCreateAndSealBatchRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
+  { auto _e = evict_if_full(); _o->evict_if_full = _e; }
+  { auto _e = data(); if (_e) { _o->data.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->data[_i] = _e->Get(_i)->str(); } } }
+  { auto _e = metadata(); if (_e) { _o->metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata[_i] = _e->Get(_i)->str(); } } }
+  { auto _e = digest(); if (_e) { _o->digest.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->digest[_i] = _e->Get(_i)->str(); } } }
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> PlasmaCreateAndSealBatchRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaCreateAndSealBatchRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBatchRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateAndSealBatchRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
+  auto _evict_if_full = _o->evict_if_full;
+  auto _data = _o->data.size() ? _fbb.CreateVectorOfStrings(_o->data) : 0;
+  auto _metadata = _o->metadata.size() ? _fbb.CreateVectorOfStrings(_o->metadata) : 0;
+  auto _digest = _o->digest.size() ? _fbb.CreateVectorOfStrings(_o->digest) : 0;
+  return plasma::flatbuf::CreatePlasmaCreateAndSealBatchRequest(
+      _fbb,
+      _object_ids,
+      _evict_if_full,
+      _data,
+      _metadata,
+      _digest);
+}
+
+inline PlasmaCreateAndSealBatchReplyT *PlasmaCreateAndSealBatchReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealBatchReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealBatchReplyT>(new PlasmaCreateAndSealBatchReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaCreateAndSealBatchReply::UnPackTo(PlasmaCreateAndSealBatchReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = error(); _o->error = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealBatchReply> PlasmaCreateAndSealBatchReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaCreateAndSealBatchReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndSealBatchReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateAndSealBatchReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _error = _o->error;
+  return plasma::flatbuf::CreatePlasmaCreateAndSealBatchReply(
+      _fbb,
+      _error);
+}
+
+inline PlasmaAbortRequestT *PlasmaAbortRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaAbortRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaAbortRequestT>(new PlasmaAbortRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaAbortRequest::UnPackTo(PlasmaAbortRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+}
+
+inline flatbuffers::Offset<PlasmaAbortRequest> PlasmaAbortRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaAbortRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaAbortRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  return plasma::flatbuf::CreatePlasmaAbortRequest(
+      _fbb,
+      _object_id);
+}
+
+inline PlasmaAbortReplyT *PlasmaAbortReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaAbortReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaAbortReplyT>(new PlasmaAbortReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaAbortReply::UnPackTo(PlasmaAbortReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+}
+
+inline flatbuffers::Offset<PlasmaAbortReply> PlasmaAbortReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaAbortReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaAbortReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  return plasma::flatbuf::CreatePlasmaAbortReply(
+      _fbb,
+      _object_id);
+}
+
+inline PlasmaSealRequestT *PlasmaSealRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaSealRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSealRequestT>(new PlasmaSealRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaSealRequest::UnPackTo(PlasmaSealRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = digest(); if (_e) _o->digest = _e->str(); }
+}
+
+inline flatbuffers::Offset<PlasmaSealRequest> PlasmaSealRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaSealRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSealRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _digest = _o->digest.empty() ? 0 : _fbb.CreateString(_o->digest);
+  return plasma::flatbuf::CreatePlasmaSealRequest(
+      _fbb,
+      _object_id,
+      _digest);
+}
+
+inline PlasmaSealReplyT *PlasmaSealReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaSealReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSealReplyT>(new PlasmaSealReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaSealReply::UnPackTo(PlasmaSealReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = error(); _o->error = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaSealReply> PlasmaSealReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaSealReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSealReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _error = _o->error;
+  return plasma::flatbuf::CreatePlasmaSealReply(
+      _fbb,
+      _object_id,
+      _error);
+}
+
+inline PlasmaGetRequestT *PlasmaGetRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaGetRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaGetRequestT>(new PlasmaGetRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaGetRequest::UnPackTo(PlasmaGetRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
+  { auto _e = timeout_ms(); _o->timeout_ms = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaGetRequest> PlasmaGetRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaGetRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaGetRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
+  auto _timeout_ms = _o->timeout_ms;
+  return plasma::flatbuf::CreatePlasmaGetRequest(
+      _fbb,
+      _object_ids,
+      _timeout_ms);
+}
+
+inline PlasmaGetReplyT *PlasmaGetReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaGetReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaGetReplyT>(new PlasmaGetReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaGetReply::UnPackTo(PlasmaGetReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
+  { auto _e = plasma_objects(); if (_e) { _o->plasma_objects.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->plasma_objects[_i] = *_e->Get(_i); } } }
+  { auto _e = store_fds(); if (_e) { _o->store_fds.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->store_fds[_i] = _e->Get(_i); } } }
+  { auto _e = mmap_sizes(); if (_e) { _o->mmap_sizes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mmap_sizes[_i] = _e->Get(_i); } } }
+  { auto _e = handles(); if (_e) { _o->handles.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->handles[_i] = std::unique_ptr<plasma::flatbuf::CudaHandleT>(_e->Get(_i)->UnPack(_resolver)); } } }
+}
+
+inline flatbuffers::Offset<PlasmaGetReply> PlasmaGetReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaGetReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaGetReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
+  auto _plasma_objects = _o->plasma_objects.size() ? _fbb.CreateVectorOfStructs(_o->plasma_objects) : 0;
+  auto _store_fds = _o->store_fds.size() ? _fbb.CreateVector(_o->store_fds) : 0;
+  auto _mmap_sizes = _o->mmap_sizes.size() ? _fbb.CreateVector(_o->mmap_sizes) : 0;
+  auto _handles = _o->handles.size() ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>> (_o->handles.size(), [](size_t i, _VectorArgs *__va) { return CreateCudaHandle(*__va->__fbb, __va->__o->handles[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return plasma::flatbuf::CreatePlasmaGetReply(
+      _fbb,
+      _object_ids,
+      _plasma_objects,
+      _store_fds,
+      _mmap_sizes,
+      _handles);
+}
+
+inline PlasmaReleaseRequestT *PlasmaReleaseRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaReleaseRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaReleaseRequestT>(new PlasmaReleaseRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaReleaseRequest::UnPackTo(PlasmaReleaseRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+}
+
+inline flatbuffers::Offset<PlasmaReleaseRequest> PlasmaReleaseRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaReleaseRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaReleaseRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  return plasma::flatbuf::CreatePlasmaReleaseRequest(
+      _fbb,
+      _object_id);
+}
+
+inline PlasmaReleaseReplyT *PlasmaReleaseReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaReleaseReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaReleaseReplyT>(new PlasmaReleaseReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaReleaseReply::UnPackTo(PlasmaReleaseReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = error(); _o->error = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaReleaseReply> PlasmaReleaseReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaReleaseReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaReleaseReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _error = _o->error;
+  return plasma::flatbuf::CreatePlasmaReleaseReply(
+      _fbb,
+      _object_id,
+      _error);
+}
+
+inline PlasmaDeleteRequestT *PlasmaDeleteRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaDeleteRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaDeleteRequestT>(new PlasmaDeleteRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaDeleteRequest::UnPackTo(PlasmaDeleteRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = count(); _o->count = _e; }
+  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
+}
+
+inline flatbuffers::Offset<PlasmaDeleteRequest> PlasmaDeleteRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaDeleteRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaDeleteRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _count = _o->count;
+  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
+  return plasma::flatbuf::CreatePlasmaDeleteRequest(
+      _fbb,
+      _count,
+      _object_ids);
+}
+
+inline PlasmaDeleteReplyT *PlasmaDeleteReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaDeleteReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaDeleteReplyT>(new PlasmaDeleteReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaDeleteReply::UnPackTo(PlasmaDeleteReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = count(); _o->count = _e; }
+  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
+  { auto _e = errors(); if (_e) { _o->errors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->errors[_i] = static_cast<plasma::flatbuf::PlasmaError>(_e->Get(_i)); } } }
+}
+
+inline flatbuffers::Offset<PlasmaDeleteReply> PlasmaDeleteReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaDeleteReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaDeleteReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _count = _o->count;
+  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
+  auto _errors = _o->errors.size() ? _fbb.CreateVectorScalarCast<int32_t>(flatbuffers::data(_o->errors), _o->errors.size()) : 0;
+  return plasma::flatbuf::CreatePlasmaDeleteReply(
+      _fbb,
+      _count,
+      _object_ids,
+      _errors);
+}
+
+inline PlasmaContainsRequestT *PlasmaContainsRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaContainsRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaContainsRequestT>(new PlasmaContainsRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaContainsRequest::UnPackTo(PlasmaContainsRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+}
+
+inline flatbuffers::Offset<PlasmaContainsRequest> PlasmaContainsRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaContainsRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaContainsRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  return plasma::flatbuf::CreatePlasmaContainsRequest(
+      _fbb,
+      _object_id);
+}
+
+inline PlasmaContainsReplyT *PlasmaContainsReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaContainsReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaContainsReplyT>(new PlasmaContainsReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaContainsReply::UnPackTo(PlasmaContainsReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = has_object(); _o->has_object = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaContainsReply> PlasmaContainsReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaContainsReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaContainsReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _has_object = _o->has_object;
+  return plasma::flatbuf::CreatePlasmaContainsReply(
+      _fbb,
+      _object_id,
+      _has_object);
+}
+
+inline PlasmaListRequestT *PlasmaListRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaListRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaListRequestT>(new PlasmaListRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaListRequest::UnPackTo(PlasmaListRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+}
+
+inline flatbuffers::Offset<PlasmaListRequest> PlasmaListRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaListRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaListRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  return plasma::flatbuf::CreatePlasmaListRequest(
+      _fbb);
+}
+
+inline PlasmaListReplyT *PlasmaListReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaListReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaListReplyT>(new PlasmaListReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaListReply::UnPackTo(PlasmaListReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = objects(); if (_e) { _o->objects.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->objects[_i] = std::unique_ptr<plasma::flatbuf::ObjectInfoT>(_e->Get(_i)->UnPack(_resolver)); } } }
+}
+
+inline flatbuffers::Offset<PlasmaListReply> PlasmaListReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaListReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaListReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _objects = _o->objects.size() ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> (_o->objects.size(), [](size_t i, _VectorArgs *__va) { return CreateObjectInfo(*__va->__fbb, __va->__o->objects[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return plasma::flatbuf::CreatePlasmaListReply(
+      _fbb,
+      _objects);
+}
+
+inline PlasmaConnectRequestT *PlasmaConnectRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaConnectRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaConnectRequestT>(new PlasmaConnectRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaConnectRequest::UnPackTo(PlasmaConnectRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+}
+
+inline flatbuffers::Offset<PlasmaConnectRequest> PlasmaConnectRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaConnectRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaConnectRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  return plasma::flatbuf::CreatePlasmaConnectRequest(
+      _fbb);
+}
+
+inline PlasmaConnectReplyT *PlasmaConnectReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaConnectReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaConnectReplyT>(new PlasmaConnectReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaConnectReply::UnPackTo(PlasmaConnectReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = memory_capacity(); _o->memory_capacity = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaConnectReply> PlasmaConnectReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaConnectReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaConnectReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _memory_capacity = _o->memory_capacity;
+  return plasma::flatbuf::CreatePlasmaConnectReply(
+      _fbb,
+      _memory_capacity);
+}
+
+inline PlasmaEvictRequestT *PlasmaEvictRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaEvictRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaEvictRequestT>(new PlasmaEvictRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaEvictRequest::UnPackTo(PlasmaEvictRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = num_bytes(); _o->num_bytes = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaEvictRequest> PlasmaEvictRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaEvictRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaEvictRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _num_bytes = _o->num_bytes;
+  return plasma::flatbuf::CreatePlasmaEvictRequest(
+      _fbb,
+      _num_bytes);
+}
+
+inline PlasmaEvictReplyT *PlasmaEvictReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaEvictReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaEvictReplyT>(new PlasmaEvictReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaEvictReply::UnPackTo(PlasmaEvictReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = num_bytes(); _o->num_bytes = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaEvictReply> PlasmaEvictReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaEvictReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaEvictReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _num_bytes = _o->num_bytes;
+  return plasma::flatbuf::CreatePlasmaEvictReply(
+      _fbb,
+      _num_bytes);
+}
+
+inline PlasmaSubscribeRequestT *PlasmaSubscribeRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaSubscribeRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSubscribeRequestT>(new PlasmaSubscribeRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaSubscribeRequest::UnPackTo(PlasmaSubscribeRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+}
+
+inline flatbuffers::Offset<PlasmaSubscribeRequest> PlasmaSubscribeRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSubscribeRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaSubscribeRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSubscribeRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSubscribeRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  return plasma::flatbuf::CreatePlasmaSubscribeRequest(
+      _fbb);
+}
+
+inline PlasmaNotificationT *PlasmaNotification::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaNotificationT> _o = std::unique_ptr<plasma::flatbuf::PlasmaNotificationT>(new PlasmaNotificationT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaNotification::UnPackTo(PlasmaNotificationT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_info(); if (_e) { _o->object_info.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_info[_i] = std::unique_ptr<plasma::flatbuf::ObjectInfoT>(_e->Get(_i)->UnPack(_resolver)); } } }
+}
+
+inline flatbuffers::Offset<PlasmaNotification> PlasmaNotification::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaNotificationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaNotification(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaNotificationT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaNotificationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_info = _o->object_info.size() ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> (_o->object_info.size(), [](size_t i, _VectorArgs *__va) { return CreateObjectInfo(*__va->__fbb, __va->__o->object_info[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return plasma::flatbuf::CreatePlasmaNotification(
+      _fbb,
+      _object_info);
+}
+
+inline PlasmaDataRequestT *PlasmaDataRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaDataRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaDataRequestT>(new PlasmaDataRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaDataRequest::UnPackTo(PlasmaDataRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = address(); if (_e) _o->address = _e->str(); }
+  { auto _e = port(); _o->port = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaDataRequest> PlasmaDataRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaDataRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaDataRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _address = _o->address.empty() ? 0 : _fbb.CreateString(_o->address);
+  auto _port = _o->port;
+  return plasma::flatbuf::CreatePlasmaDataRequest(
+      _fbb,
+      _object_id,
+      _address,
+      _port);
+}
+
+inline PlasmaDataReplyT *PlasmaDataReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaDataReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaDataReplyT>(new PlasmaDataReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaDataReply::UnPackTo(PlasmaDataReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
+  { auto _e = object_size(); _o->object_size = _e; }
+  { auto _e = metadata_size(); _o->metadata_size = _e; }
+}
+
+inline flatbuffers::Offset<PlasmaDataReply> PlasmaDataReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaDataReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaDataReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
+  auto _object_size = _o->object_size;
+  auto _metadata_size = _o->metadata_size;
+  return plasma::flatbuf::CreatePlasmaDataReply(
+      _fbb,
+      _object_id,
+      _object_size,
+      _metadata_size);
+}
+
+inline PlasmaRefreshLRURequestT *PlasmaRefreshLRURequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaRefreshLRURequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaRefreshLRURequestT>(new PlasmaRefreshLRURequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaRefreshLRURequest::UnPackTo(PlasmaRefreshLRURequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
+}
+
+inline flatbuffers::Offset<PlasmaRefreshLRURequest> PlasmaRefreshLRURequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRURequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaRefreshLRURequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRURequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaRefreshLRURequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
+  return plasma::flatbuf::CreatePlasmaRefreshLRURequest(
+      _fbb,
+      _object_ids);
+}
+
+inline PlasmaRefreshLRUReplyT *PlasmaRefreshLRUReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  std::unique_ptr<plasma::flatbuf::PlasmaRefreshLRUReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaRefreshLRUReplyT>(new PlasmaRefreshLRUReplyT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void PlasmaRefreshLRUReply::UnPackTo(PlasmaRefreshLRUReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+}
+
+inline flatbuffers::Offset<PlasmaRefreshLRUReply> PlasmaRefreshLRUReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRUReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePlasmaRefreshLRUReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<PlasmaRefreshLRUReply> CreatePlasmaRefreshLRUReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRUReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaRefreshLRUReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  return plasma::flatbuf::CreatePlasmaRefreshLRUReply(
+      _fbb);
+}
+
+}  // namespace flatbuf
+}  // namespace plasma
+
+#endif  // FLATBUFFERS_GENERATED_PLASMA_PLASMA_FLATBUF_H_
diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 11cb02a9f4e..d65f9eaab4a 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -664,6 +664,26 @@ def _get_type(self):
         return OrderedDict([('name', 'largeutf8')])
 
 
+class BinaryViewField(BinaryField):
+
+    @property
+    def column_class(self):
+        return BinaryViewColumn
+
+    def _get_type(self):
+        return OrderedDict([('name', 'binaryview')])
+
+
+class StringViewField(StringField):
+
+    @property
+    def column_class(self):
+        return StringViewColumn
+
+    def _get_type(self):
+        return OrderedDict([('name', 'utf8view')])
+
+
 class Schema(object):
 
     def __init__(self, fields, metadata=None):
@@ -743,6 +763,72 @@ class LargeStringColumn(_BaseStringColumn, _LargeOffsetsMixin):
     pass
 
 
+class BinaryViewColumn(PrimitiveColumn):
+
+    def _encode_value(self, x):
+        return frombytes(binascii.hexlify(x).upper())
+
+    def _get_buffers(self):
+        char_buffers = []
+        DEFAULT_BUFFER_SIZE = 32  # ¯\_(ツ)_/¯
+        INLINE_SIZE = 12
+
+        data = []
+        for i, v in enumerate(self.values):
+            if not self.is_valid[i]:
+                v = b''
+            assert isinstance(v, bytes)
+
+            if len(v) > INLINE_SIZE:
+                offset = 0
+                if len(v) > DEFAULT_BUFFER_SIZE:
+                    char_buffers.append(v)
+                else:
+                    if len(char_buffers) == 0:
+                        char_buffers.append(v)
+                    elif len(char_buffers[-1]) + len(v) > DEFAULT_BUFFER_SIZE:
+                        char_buffers.append(v)
+                    else:
+                        offset = len(char_buffers[-1])
+                        char_buffers[-1] += v
+                        assert len(char_buffers[-1]) <= DEFAULT_BUFFER_SIZE
+
+                buffer_index = len(char_buffers) - 1
+
+                # the prefix is always 4 bytes so it may not be utf-8
+                # even if the whole string view is
+                prefix = v[:4].ljust(4, b'\0')
+                prefix = frombytes(binascii.hexlify(prefix).upper())
+
+                data.append(OrderedDict([
+                    ('SIZE', len(v)),
+                    ('PREFIX', prefix),
+                    ('BUFFER_INDEX', buffer_index),
+                    ('OFFSET', offset),
+                ]))
+            else:
+                inlined = self._encode_value(v.ljust(12, b'\0'))
+                data.append(OrderedDict([
+                    ('SIZE', len(v)),
+                    ('INLINED', inlined),
+                ]))
+
+        return [
+            ('VALIDITY', [int(x) for x in self.is_valid]),
+            ('DATA', data),
+            ('VARIADIC_BUFFERS', [
+                frombytes(binascii.hexlify(buffer).upper())
+                for buffer in char_buffers
+            ]),
+        ]
+
+
+class StringViewColumn(BinaryViewColumn):
+
+    def _encode_value(self, x):
+        return frombytes(x)
+
+
 class FixedSizeBinaryColumn(PrimitiveColumn):
 
     def _encode_value(self, x):
@@ -1541,6 +1627,15 @@ def generate_run_end_encoded_case():
     return _generate_file("run_end_encoded", fields, batch_sizes)
 
 
+def generate_view_case():
+    fields = [
+        BinaryViewField('bv'),
+        StringViewField('sv'),
+    ]
+    batch_sizes = [0, 7, 256]
+    return _generate_file("view", fields, batch_sizes)
+
+
 def generate_nested_large_offsets_case():
     fields = [
         LargeListField('large_list_nullable', get_field('item', 'int32')),
@@ -1742,6 +1837,13 @@ def _temp_path():
         .skip_category('JS')
         .skip_category('Rust'),
 
+        generate_view_case()
+        .skip_category('C#')
+        .skip_category('Go')
+        .skip_category('Java')
+        .skip_category('JS')
+        .skip_category('Rust'),
+
         generate_extension_case()
         .skip_category('C#')
         .skip_category('JS'),
diff --git a/docs/source/format/Columnar.rst b/docs/source/format/Columnar.rst
index b90e2c97ade..c1c48abc1fe 100644
--- a/docs/source/format/Columnar.rst
+++ b/docs/source/format/Columnar.rst
@@ -21,7 +21,7 @@
 Arrow Columnar Format
 *********************
 
-*Version: 1.3*
+*Version: 1.4*
 
 The "Arrow Columnar Format" includes a language-agnostic in-memory
 data structure specification, metadata serialization, and a protocol
@@ -106,8 +106,10 @@ the different physical layouts defined by Arrow:
 * **Primitive (fixed-size)**: a sequence of values each having the
   same byte or bit width
 * **Variable-size Binary**: a sequence of values each having a variable
-  byte length. Two variants of this layout are supported using 32-bit
-  and 64-bit length encoding.
+  byte length. Three variants of this layout are supported using
+  * 32-bit offset encoding
+  * 64-bit offset encoding
+  * 128-bit view-or-inline encoding
 * **Fixed-size List**: a nested layout where each value has the same
   number of elements taken from a child data type.
 * **Variable-size List**: a nested layout where each value is a
@@ -350,6 +352,51 @@ will be represented as follows: ::
     |----------------|----------------------|
     | joemark        | unspecified          |
 
+Variable-size Binary View Layout
+--------------------------------
+
+Each value in this layout consists of 0 or more bytes. These characters'
+locations are indicated using a **views** buffer, which may point to one
+of potentially several **data** buffers or may contain the characters
+inline.
+
+The views buffer contains `length` view structures with the following layout:
+
+::
+
+    * Short strings, length <= 12
+      | Bytes 0-3  | Bytes 4-15                            |
+      |------------|---------------------------------------|
+      | length     | data (padded with 0)                  |
+
+    * Long strings, length > 12
+      | Bytes 0-3  | Bytes 4-7  | Bytes 8-11 | Bytes 12-15 |
+      |------------|------------|------------|-------------|
+      | length     | prefix     | buf. index | offset      |
+
+In both the long and short string cases, the first four bytes encode the
+length of the string and can be used to determine how the rest of the view
+should be interpreted.
+
+In the short string case the string's bytes are inlined- stored inside the
+view itself, in the twelve bytes which follow the length.
+
+In the long string case, a buffer index indicates which character buffer
+stores the characters and an offset indicates where in that buffer the
+characters begin. Buffer index 0 refers to the first character buffer, IE
+the first buffer **after** the validity buffer and the views buffer.
+The half-open range ``[offset, offset + length)`` must be entirely contained
+within the indicated buffer. A copy of the first four bytes of the string is
+stored inline in the prefix, after the length. This prefix enables a
+profitable fast path for string comparisons, which are frequently determined
+within the first four bytes.
+
+Views must be aligned to an 8-byte boundary. This restriction enables more
+efficient interoperation with systems where the index and offset are replaced
+by a raw pointer. All integers (length, buffer index, and offset) are unsigned
+for compatibility with engines which already implement these views.
+This layout is adapted from TU Munich's `UmbraDB`_.
+
 .. _variable-size-list-layout:
 
 Variable-size List Layout
@@ -885,6 +932,7 @@ of memory buffers for each layout.
 
    "Primitive",validity,data,
    "Variable Binary",validity,offsets,data
+   "Variable Binary - View",validity,offsets,*multiple_data_buffers
    "List",validity,offsets,
    "Fixed-size List",validity,,
    "Struct",validity,,
@@ -1346,3 +1394,4 @@ the Arrow spec.
 .. _Endianness: https://en.wikipedia.org/wiki/Endianness
 .. _SIMD: https://software.intel.com/en-us/cpp-compiler-developer-guide-and-reference-introduction-to-the-simd-data-layout-templates
 .. _Parquet: https://parquet.apache.org/docs/
+.. _UmbraDB: https://db.in.tum.de/~freitag/papers/p29-neumann-cidr20.pdf
diff --git a/format/Message.fbs b/format/Message.fbs
index 170ea8fbced..2633f4dd97b 100644
--- a/format/Message.fbs
+++ b/format/Message.fbs
@@ -99,6 +99,12 @@ table RecordBatch {
 
   /// Optional compression of the message body
   compression: BodyCompression;
+
+  /// Some types such as Utf8View are represented using a variable number of buffers.
+  /// For each such Field in the pre-ordered flattened logical schema, there will be
+  /// an entry in variadicCounts to indicate the number of extra buffers which belong
+  /// to that Field.
+  variadicCounts: [long];
 }
 
 /// For sending dictionary encoding information. Any Field can be
diff --git a/format/Schema.fbs b/format/Schema.fbs
index ce29c25b7d1..e3a51fd9a11 100644
--- a/format/Schema.fbs
+++ b/format/Schema.fbs
@@ -22,6 +22,7 @@
 /// Version 1.1 - Add Decimal256.
 /// Version 1.2 - Add Interval MONTH_DAY_NANO.
 /// Version 1.3 - Add Run-End Encoded.
+/// Version 1.4 - Add BinaryView and Utf8View.
 
 namespace org.apache.arrow.flatbuf;
 
@@ -171,6 +172,17 @@ table LargeUtf8 {
 table LargeBinary {
 }
 
+/// Same as Utf8, but string characters are delimited with a packed
+/// length/pointer instead of offsets.
+table Utf8View {
+}
+
+/// Same as Binary, but string characters are delimited with a packed
+/// length/pointeBinary of offsets.
+table BinaryView {
+}
+
+
 table FixedSizeBinary {
   /// Number of bytes per value
   byteWidth: int;
@@ -427,6 +439,8 @@ union Type {
   LargeUtf8,
   LargeList,
   RunEndEncoded,
+  BinaryView,
+  Utf8View,
 }
 
 /// ----------------------------------------------------------------------
diff --git a/python/pyarrow/src/arrow/python/arrow_to_pandas.cc b/python/pyarrow/src/arrow/python/arrow_to_pandas.cc
index f6b7ca9d54a..128d98bb76d 100644
--- a/python/pyarrow/src/arrow/python/arrow_to_pandas.cc
+++ b/python/pyarrow/src/arrow/python/arrow_to_pandas.cc
@@ -116,39 +116,21 @@ void BufferCapsule_Destructor(PyObject* capsule) {
 using internal::arrow_traits;
 using internal::npy_traits;
 
-template <typename T>
+template <typename T, typename Enable = void>
 struct WrapBytes {};
 
-template <>
-struct WrapBytes<StringType> {
-  static inline PyObject* Wrap(const char* data, int64_t length) {
-    return PyUnicode_FromStringAndSize(data, length);
-  }
-};
-
-template <>
-struct WrapBytes<LargeStringType> {
+template <typename T>
+struct WrapBytes<T,
+                 enable_if_t<is_string_type<T>::value || is_string_view_type<T>::value>> {
   static inline PyObject* Wrap(const char* data, int64_t length) {
     return PyUnicode_FromStringAndSize(data, length);
   }
 };
 
-template <>
-struct WrapBytes<BinaryType> {
-  static inline PyObject* Wrap(const char* data, int64_t length) {
-    return PyBytes_FromStringAndSize(data, length);
-  }
-};
-
-template <>
-struct WrapBytes<LargeBinaryType> {
-  static inline PyObject* Wrap(const char* data, int64_t length) {
-    return PyBytes_FromStringAndSize(data, length);
-  }
-};
-
-template <>
-struct WrapBytes<FixedSizeBinaryType> {
+template <typename T>
+struct WrapBytes<T,
+                 enable_if_t<is_binary_type<T>::value || is_binary_view_type<T>::value ||
+                             is_fixed_size_binary_type<T>::value>> {
   static inline PyObject* Wrap(const char* data, int64_t length) {
     return PyBytes_FromStringAndSize(data, length);
   }
@@ -1150,7 +1132,8 @@ struct ObjectWriterVisitor {
   }
 
   template <typename Type>
-  enable_if_t<is_base_binary_type<Type>::value || is_fixed_size_binary_type<Type>::value,
+  enable_if_t<is_base_binary_type<Type>::value || is_binary_view_like_type<Type>::value ||
+                  is_fixed_size_binary_type<Type>::value,
               Status>
   Visit(const Type& type) {
     auto WrapValue = [](const std::string_view& view, PyObject** out) {
diff --git a/python/pyarrow/src/arrow/python/python_to_arrow.cc b/python/pyarrow/src/arrow/python/python_to_arrow.cc
index 4f7420d8295..b7dac78b401 100644
--- a/python/pyarrow/src/arrow/python/python_to_arrow.cc
+++ b/python/pyarrow/src/arrow/python/python_to_arrow.cc
@@ -479,13 +479,17 @@ class PyValue {
 
   // The binary-like intermediate representation is PyBytesView because it keeps temporary
   // python objects alive (non-contiguous memoryview) and stores whether the original
-  // object was unicode encoded or not, which is used for unicode -> bytes coersion if
+  // object was unicode encoded or not, which is used for unicode -> bytes coercion if
   // there is a non-unicode object observed.
 
   static Status Convert(const BaseBinaryType*, const O&, I obj, PyBytesView& view) {
     return view.ParseString(obj);
   }
 
+  static Status Convert(const BinaryViewType*, const O&, I obj, PyBytesView& view) {
+    return view.ParseString(obj);
+  }
+
   static Status Convert(const FixedSizeBinaryType* type, const O&, I obj,
                         PyBytesView& view) {
     ARROW_RETURN_NOT_OK(view.ParseString(obj));
@@ -672,12 +676,9 @@ class PyPrimitiveConverter<T, enable_if_t<std::is_same<T, FixedSizeBinaryType>::
   PyBytesView view_;
 };
 
-template <typename T>
-class PyPrimitiveConverter<T, enable_if_base_binary<T>>
-    : public PrimitiveConverter<T, PyConverter> {
+template <typename T, typename OffsetType>
+class PyBinaryConverter : public PrimitiveConverter<T, PyConverter> {
  public:
-  using OffsetType = typename T::offset_type;
-
   Status Append(PyObject* value) override {
     if (PyValue::IsNull(this->options_, value)) {
       this->primitive_builder_->UnsafeAppendNull();
@@ -701,7 +702,7 @@ class PyPrimitiveConverter<T, enable_if_base_binary<T>>
   Result<std::shared_ptr<Array>> ToArray() override {
     ARROW_ASSIGN_OR_RAISE(auto array, (PrimitiveConverter<T, PyConverter>::ToArray()));
     if (observed_binary_) {
-      // if we saw any non-unicode, cast results to BinaryArray
+      // if we saw any non-unicode, cast results to BinaryArray/BinaryViewArray
       auto binary_type = TypeTraits<typename T::PhysicalType>::type_singleton();
       return array->View(binary_type);
     } else {
@@ -714,6 +715,14 @@ class PyPrimitiveConverter<T, enable_if_base_binary<T>>
   bool observed_binary_ = false;
 };
 
+template <typename T>
+class PyPrimitiveConverter<T, enable_if_base_binary<T>>
+    : public PyBinaryConverter<T, typename T::offset_type> {};
+
+template <typename T>
+class PyPrimitiveConverter<T, enable_if_binary_view_like<T>>
+    : public PyBinaryConverter<T, int64_t> {};
+
 template <typename U>
 class PyDictionaryConverter<U, enable_if_has_c_type<U>>
     : public DictionaryConverter<U, PyConverter> {
diff --git a/r/src/r_to_arrow.cpp b/r/src/r_to_arrow.cpp
index 19c23973a62..fe9c0a78498 100644
--- a/r/src/r_to_arrow.cpp
+++ b/r/src/r_to_arrow.cpp
@@ -794,11 +794,10 @@ Status check_binary(SEXP x, int64_t size) {
 }
 
 template <typename T>
-class RPrimitiveConverter<T, enable_if_binary<T>>
+class RPrimitiveConverter<
+    T, enable_if_t<is_binary_like_type<T>::value && !is_decimal_type<T>::value>>
     : public PrimitiveConverter<T, RConverter> {
  public:
-  using OffsetType = typename T::offset_type;
-
   Status Extend(SEXP x, int64_t size, int64_t offset = 0) override {
     RETURN_NOT_OK(this->Reserve(size - offset));
     RETURN_NOT_OK(check_binary(x, size));
@@ -811,39 +810,18 @@ class RPrimitiveConverter<T, enable_if_binary<T>>
     auto append_value = [this](SEXP raw) {
       R_xlen_t n = XLENGTH(raw);
       ARROW_RETURN_NOT_OK(this->primitive_builder_->ReserveData(n));
-      this->primitive_builder_->UnsafeAppend(RAW_RO(raw), static_cast<OffsetType>(n));
-      return Status::OK();
-    };
-    return VisitVector(RVectorIterator<SEXP>(x, offset), size, append_null, append_value);
-  }
-
-  void DelayedExtend(SEXP values, int64_t size, RTasks& tasks) override {
-    auto task = [this, values, size]() { return this->Extend(values, size); };
-    tasks.Append(!ALTREP(values), std::move(task));
-  }
-};
 
-template <typename T>
-class RPrimitiveConverter<T, enable_if_t<std::is_same<T, FixedSizeBinaryType>::value>>
-    : public PrimitiveConverter<T, RConverter> {
- public:
-  Status Extend(SEXP x, int64_t size, int64_t offset = 0) override {
-    RETURN_NOT_OK(this->Reserve(size - offset));
-    RETURN_NOT_OK(check_binary(x, size));
-
-    auto append_null = [this]() {
-      this->primitive_builder_->UnsafeAppendNull();
-      return Status::OK();
-    };
-
-    auto append_value = [this](SEXP raw) {
-      R_xlen_t n = XLENGTH(raw);
-
-      if (n != this->primitive_builder_->byte_width()) {
-        return Status::Invalid("invalid size");
+      if constexpr (std::is_same_v<T, FixedSizeBinaryType>) {
+        if (n != this->primitive_builder_->byte_width()) {
+          return Status::Invalid("invalid size");
+        }
+        this->primitive_builder_->UnsafeAppend(RAW_RO(raw));
+      } else if constexpr (std::is_same_v<T, BinaryViewType>) {
+        this->primitive_builder_->UnsafeAppend(RAW_RO(raw), static_cast<int64_t>(n));
+      } else {
+        this->primitive_builder_->UnsafeAppend(RAW_RO(raw),
+                                               static_cast<typename T::offset_type>(n));
       }
-      ARROW_RETURN_NOT_OK(this->primitive_builder_->ReserveData(n));
-      this->primitive_builder_->UnsafeAppend(RAW_RO(raw));
       return Status::OK();
     };
     return VisitVector(RVectorIterator<SEXP>(x, offset), size, append_null, append_value);
@@ -859,8 +837,6 @@ template <typename T>
 class RPrimitiveConverter<T, enable_if_string_like<T>>
     : public PrimitiveConverter<T, RConverter> {
  public:
-  using OffsetType = typename T::offset_type;
-
   Status Extend(SEXP x, int64_t size, int64_t offset = 0) override {
     RVectorType rtype = GetVectorType(x);
     if (rtype != STRING) {