diff --git a/.gitignore b/.gitignore
index 6f123362ef1..73df6db05dc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,6 +20,7 @@ arrow-src.tar
 arrow-src.tar.gz
 
 # Compiled source
+cpp/debug
 *.a
 *.dll
 *.o
diff --git a/cpp/src/arrow/array/builder_primitive.h b/cpp/src/arrow/array/builder_primitive.h
index e0f39f97967..2eebe2ffc69 100644
--- a/cpp/src/arrow/array/builder_primitive.h
+++ b/cpp/src/arrow/array/builder_primitive.h
@@ -293,6 +293,9 @@ using Int64Builder = NumericBuilder<Int64Type>;
 using HalfFloatBuilder = NumericBuilder<HalfFloatType>;
 using FloatBuilder = NumericBuilder<FloatType>;
 using DoubleBuilder = NumericBuilder<DoubleType>;
+using ComplexFloatBuilder = NumericBuilder<ComplexFloatType>;
+using ComplexDoubleBuilder = NumericBuilder<ComplexDoubleType>;
+
 
 class ARROW_EXPORT BooleanBuilder : public ArrayBuilder {
  public:
diff --git a/cpp/src/arrow/array/diff.cc b/cpp/src/arrow/array/diff.cc
index a94ca178a40..b6b1e70fd04 100644
--- a/cpp/src/arrow/array/diff.cc
+++ b/cpp/src/arrow/array/diff.cc
@@ -410,9 +410,21 @@ class MakeFormatterImpl {
     return Status::OK();
   }
 
+template <typename T>
+enable_if_complex<T, Status> Visit(const T&) {
+  impl_ = [](const Array& array, int64_t index, std::ostream* os) {
+    const auto& numeric = checked_cast<const NumericArray<T>&>(array);
+    *os << numeric.Value(index);
+  };
+  return Status::OK();
+}
+
+
   // format Numerics with std::ostream defaults
   template <typename T>
-  enable_if_number<T, Status> Visit(const T&) {
+  enable_if_t<is_number_type<T>::value &&
+              !is_complex_type<T>::value, Status>
+  Visit(const T&) {
     impl_ = [](const Array& array, int64_t index, std::ostream* os) {
       const auto& numeric = checked_cast<const NumericArray<T>&>(array);
       if (sizeof(decltype(numeric.Value(index))) == sizeof(char)) {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 86e321ba522..f4cde72cc90 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -105,6 +105,35 @@ struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
   ScalarAggregateOptions options;
 };
 
+
+template <SimdLevel::type SimdLevel>
+struct MeanImpl<ComplexFloatType, SimdLevel> : public SumImpl<ComplexFloatType, SimdLevel> {
+  Status Finalize(KernelContext*, Datum* out) override {
+    if (this->count < options.min_count) {
+      out->value = std::make_shared<ComplexDoubleScalar>();
+    } else {
+      const std::complex<double> mean = this->sum / double(this->count);
+      out->value = std::make_shared<ComplexDoubleScalar>(mean);
+    }
+    return Status::OK();
+  }
+  ScalarAggregateOptions options;
+};
+
+template <SimdLevel::type SimdLevel>
+struct MeanImpl<ComplexDoubleType, SimdLevel> : public SumImpl<ComplexDoubleType, SimdLevel> {
+  Status Finalize(KernelContext*, Datum* out) override {
+    if (this->count < options.min_count) {
+      out->value = std::make_shared<ComplexDoubleScalar>();
+    } else {
+      const std::complex<double> mean = this->sum / double(this->count);
+      out->value = std::make_shared<ComplexDoubleScalar>(mean);
+    }
+    return Status::OK();
+  }
+  ScalarAggregateOptions options;
+};
+
 template <template <typename> class KernelClass>
 struct SumLikeInit {
   std::unique_ptr<KernelState> state;
@@ -217,6 +246,39 @@ struct MinMaxState<ArrowType, SimdLevel, enable_if_floating_point<ArrowType>> {
   bool has_values = false;
 };
 
+template <typename ArrowType, SimdLevel::type SimdLevel>
+struct MinMaxState<ArrowType, SimdLevel, enable_if_complex<ArrowType>> {
+  using ThisType = MinMaxState<ArrowType, SimdLevel>;
+  using T = typename ArrowType::c_type;
+  using R = typename T::value_type;
+
+  ThisType& operator+=(const ThisType& rhs) {
+    this->has_nulls |= rhs.has_nulls;
+    this->has_values |= rhs.has_values;
+    this->min = T(std::fmin(this->min.real(), rhs.min.real()),
+                  std::fmin(this->min.imag(), rhs.min.imag()));
+    this->max = T(std::fmax(this->max.real(), rhs.max.real()),
+                  std::fmax(this->max.imag(), rhs.max.imag()));
+    return *this;
+  }
+
+  void MergeOne(T value) {
+    this->min = T(std::fmin(this->min.real(), value.real()),
+                  std::fmin(this->min.imag(), value.imag()));
+    this->max = T(std::fmax(this->max.real(), value.real()),
+                  std::fmax(this->max.imag(), value.imag()));
+  }
+
+  T min = T(std::numeric_limits<R>::infinity(),
+            std::numeric_limits<R>::infinity());
+  T max = T(-std::numeric_limits<R>::infinity(),
+            -std::numeric_limits<R>::infinity());
+
+  bool has_nulls = false;
+  bool has_values = false;
+};
+
+
 template <typename ArrowType, SimdLevel::type SimdLevel>
 struct MinMaxImpl : public ScalarAggregator {
   using ArrayType = typename TypeTraits<ArrowType>::ArrayType;
diff --git a/cpp/src/arrow/compute/kernels/aggregate_internal.h b/cpp/src/arrow/compute/kernels/aggregate_internal.h
index d74881108ae..91678265255 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_internal.h
@@ -49,6 +49,12 @@ struct FindAccumulatorType<I, enable_if_floating_point<I>> {
   using Type = DoubleType;
 };
 
+template <typename I>
+struct FindAccumulatorType<I, enable_if_complex<I>> {
+  using Type = ComplexDoubleType;
+};
+
+
 struct ScalarAggregator : public KernelState {
   virtual Status Consume(KernelContext* ctx, const ExecBatch& batch) = 0;
   virtual Status MergeFrom(KernelContext* ctx, KernelState&& src) = 0;
@@ -66,7 +72,8 @@ using arrow::internal::VisitSetBitRunsVoid;
 // non-recursive pairwise summation for floating points
 // https://en.wikipedia.org/wiki/Pairwise_summation
 template <typename ValueType, typename SumType, typename ValueFunc>
-enable_if_t<std::is_floating_point<SumType>::value, SumType> SumArray(
+enable_if_t<std::is_floating_point<SumType>::value ||
+            is_complex_type<SumType>::value, SumType> SumArray(
     const ArrayData& data, ValueFunc&& func) {
   const int64_t data_size = data.length - data.GetNullCount();
   if (data_size == 0) {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_var_std.cc b/cpp/src/arrow/compute/kernels/aggregate_var_std.cc
index 29b2adce3bd..c27a0bbcbbf 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_var_std.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_var_std.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include <cmath>
+#include <complex>
 
 #include "arrow/compute/api_aggregate.h"
 #include "arrow/compute/kernels/aggregate_internal.h"
@@ -32,16 +33,50 @@ namespace {
 using arrow::internal::int128_t;
 using arrow::internal::VisitSetBitRunsVoid;
 
+template <typename ArrowType> struct VarStdTraits {
+  using MeanType = double;
+  using VarType = double;
+  using StdType = double;
+
+  static inline VarType mean_squared(MeanType mean) {
+    return mean*mean;
+  }
+};
+
+template <> struct VarStdTraits<ComplexFloatType> {
+  using MeanType = std::complex<double>;
+  using VarType = double;
+  using StdType = double;
+
+  static inline VarType mean_squared(MeanType mean) {
+    return mean.real()*mean.real() + mean.imag() + mean.imag();
+  }
+};
+
+template <> struct VarStdTraits<ComplexDoubleType> {
+  using MeanType = std::complex<double>;
+  using VarType = double;
+  using StdType = double;
+
+  static inline VarType mean_squared(MeanType mean) {
+    return mean.real()*mean.real() + mean.imag() + mean.imag();
+  }
+};
+
+
 template <typename ArrowType>
 struct VarStdState {
   using ArrayType = typename TypeTraits<ArrowType>::ArrayType;
   using CType = typename ArrowType::c_type;
   using ThisType = VarStdState<ArrowType>;
+  using Traits = VarStdTraits<ArrowType>;
+  using MeanType = typename Traits::MeanType;
 
   // float/double/int64: calculate `m2` (sum((X-mean)^2)) with `two pass algorithm`
   // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Two-pass_algorithm
   template <typename T = ArrowType>
-  enable_if_t<is_floating_type<T>::value || (sizeof(CType) > 4)> Consume(
+  enable_if_t<is_floating_type<T>::value ||
+              (is_integer_type<T>::value && sizeof(CType) > 4)> Consume(
       const ArrayType& array) {
     int64_t count = array.length() - array.null_count();
     if (count == 0) {
@@ -52,7 +87,7 @@ struct VarStdState {
         typename std::conditional<is_floating_type<T>::value, double, int128_t>::type;
     SumType sum = arrow::compute::detail::SumArray<CType, SumType>(*array.data());
 
-    const double mean = static_cast<double>(sum) / count;
+    const MeanType mean = static_cast<double>(sum) / count;
     const double m2 = arrow::compute::detail::SumArray<CType, double>(
         *array.data(), [mean](CType value) {
           const double v = static_cast<double>(value);
@@ -64,6 +99,30 @@ struct VarStdState {
     this->m2 = m2;
   }
 
+  // complex numbers
+  template <typename T = ArrowType>
+  enable_if_t<is_complex_type<T>::value> Consume(
+      const ArrayType& array) {
+    int64_t count = array.length() - array.null_count();
+    if (count == 0) {
+      return;
+    }
+
+    MeanType sum = arrow::compute::detail::SumArray<CType, MeanType>(*array.data());
+
+    const MeanType mean = static_cast<MeanType>(sum) / double(count);
+    const double m2 = arrow::compute::detail::SumArray<CType, double>(
+        *array.data(), [mean](CType value) {
+          const MeanType v = static_cast<MeanType>(value);
+          return Traits::mean_squared(v - mean);
+        });
+
+    this->count = count;
+    this->mean = mean;
+    this->m2 = m2;
+  }
+
+
   // int32/16/8: textbook one pass algorithm with integer arithmetic
   template <typename T = ArrowType>
   enable_if_t<is_integer_type<T>::value && (sizeof(CType) <= 4)> Consume(
@@ -127,16 +186,19 @@ struct VarStdState {
       this->m2 = state.m2;
       return;
     }
-    double mean = (this->mean * this->count + state.mean * state.count) /
-                  (this->count + state.count);
-    this->m2 += state.m2 + this->count * (this->mean - mean) * (this->mean - mean) +
-                state.count * (state.mean - mean) * (state.mean - mean);
+    double this_count = double(this->count);
+    double state_count = double(state.count);
+
+    MeanType mean = (this->mean * this_count + state.mean * state_count) /
+                  (this_count + state_count);
+    this->m2 += state.m2 + this_count * Traits::mean_squared(this->mean - mean) +
+                state_count * Traits::mean_squared(state.mean - mean);
     this->count += state.count;
     this->mean = mean;
   }
 
   int64_t count = 0;
-  double mean = 0;
+  MeanType mean = 0;
   double m2 = 0;  // m2 = count*s2 = sum((X-mean)^2)
 };
 
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
index e282035d82a..0edff345e32 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <complex>
 #include <functional>
 #include <memory>
 #include <string>
@@ -942,6 +943,30 @@ struct Extrema<double> {
   static constexpr double max() { return std::numeric_limits<double>::infinity(); }
 };
 
+template <>
+struct Extrema<std::complex<float>> {
+  static constexpr std::complex<float> min() {
+    return std::complex<float>(-std::numeric_limits<float>::infinity(),
+                               -std::numeric_limits<float>::infinity());
+  }
+  static constexpr std::complex<float> max() {
+    return std::complex<float>(std::numeric_limits<float>::infinity(),
+                               std::numeric_limits<float>::infinity());
+  }
+};
+
+template <>
+struct Extrema<std::complex<double>> {
+  static constexpr std::complex<double> min() {
+    return std::complex<double>(-std::numeric_limits<double>::infinity(),
+                                -std::numeric_limits<double>::infinity());
+  }
+  static constexpr std::complex<double> max() {
+    return std::complex<double>(std::numeric_limits<double>::infinity(),
+                                std::numeric_limits<double>::infinity());
+  }
+};
+
 struct GroupedMinMaxImpl : public GroupedAggregator {
   using ConsumeImpl =
       std::function<void(const std::shared_ptr<ArrayData>&, const uint32_t*, void*, void*,
@@ -962,7 +987,8 @@ struct GroupedMinMaxImpl : public GroupedAggregator {
 
   struct GetImpl {
     template <typename T, typename CType = typename TypeTraits<T>::CType>
-    enable_if_number<T, Status> Visit(const T&) {
+    enable_if_t<is_number_type<T>::value && ! is_complex_type<T>::value, Status>
+    Visit(const T&) {
       consume_impl = [](const std::shared_ptr<ArrayData>& input, const uint32_t* group,
                         void* mins, void* maxes, uint8_t* has_values,
                         uint8_t* has_nulls) {
@@ -984,6 +1010,32 @@ struct GroupedMinMaxImpl : public GroupedAggregator {
       return Status::OK();
     }
 
+    template <typename T, typename CType = typename TypeTraits<T>::CType>
+    enable_if_t<is_number_type<T>::value && is_complex_type<T>::value, Status>
+    Visit(const T&) {
+      consume_impl = [](const std::shared_ptr<ArrayData>& input, const uint32_t* group,
+                        void* mins, void* maxes, uint8_t* has_values,
+                        uint8_t* has_nulls) {
+        auto raw_mins = reinterpret_cast<CType*>(mins);
+        auto raw_maxes = reinterpret_cast<CType*>(maxes);
+
+        VisitArrayDataInline<T>(
+            *input,
+            [&](const CType & val) {
+              raw_maxes[*group] = CType(std::max(raw_maxes[*group].real(), val.real()),
+                                        std::max(raw_maxes[*group].imag(), val.imag()));
+              raw_maxes[*group] = CType(std::min(raw_mins[*group].real(), val.real()),
+                                        std::min(raw_mins[*group].imag(), val.imag()));
+            },
+            [&] { BitUtil::SetBit(has_nulls, *group++); });
+      };
+
+      resize_min_impl = MakeResizeImpl(Extrema<CType>::max());
+      resize_max_impl = MakeResizeImpl(Extrema<CType>::min());
+      return Status::OK();
+    }
+
+
     Status Visit(const BooleanType& type) {
       return Status::NotImplemented("Grouped MinMax data of type ", type);
     }
diff --git a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
index 3e2e95e5401..6dce3dd8a90 100644
--- a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
@@ -164,7 +164,14 @@ struct InitStateVisitor {
   }
 
   template <typename Type>
-  enable_if_t<has_c_type<Type>::value && !is_boolean_type<Type>::value, Status> Visit(
+  enable_if_complex<Type, Status> Visit(const Type &) {
+    return Init<Type>();
+  }
+
+  template <typename Type>
+  enable_if_t<has_c_type<Type>::value &&
+              !is_boolean_type<Type>::value &&
+              !is_complex_type<Type>::value, Status> Visit(
       const Type&) {
     return Init<typename UnsignedIntType<sizeof(typename Type::c_type)>::Type>();
   }
@@ -262,7 +269,14 @@ struct IndexInVisitor {
   }
 
   template <typename Type>
-  enable_if_t<has_c_type<Type>::value && !is_boolean_type<Type>::value, Status> Visit(
+  enable_if_complex<Type, Status> Visit(const Type&) {
+    return ProcessIndexIn<Type>();
+  }
+
+  template <typename Type>
+  enable_if_t<has_c_type<Type>::value &&
+              !is_boolean_type<Type>::value &&
+              !is_complex_type<Type>::value, Status> Visit(
       const Type&) {
     return ProcessIndexIn<
         typename UnsignedIntType<sizeof(typename Type::c_type)>::Type>();
@@ -352,7 +366,14 @@ struct IsInVisitor {
   }
 
   template <typename Type>
-  enable_if_t<has_c_type<Type>::value && !is_boolean_type<Type>::value, Status> Visit(
+  enable_if_complex<Type, Status> Visit(const Type&) {
+    return ProcessIsIn<Type>();
+  }
+
+  template <typename Type>
+  enable_if_t<has_c_type<Type>::value &&
+             !is_boolean_type<Type>::value &&
+             !is_complex_type<Type>::value, Status> Visit(
       const Type&) {
     return ProcessIsIn<typename UnsignedIntType<sizeof(typename Type::c_type)>::Type>();
   }
diff --git a/cpp/src/arrow/datum.cc b/cpp/src/arrow/datum.cc
index dd10fce3e4d..17aadee73c6 100644
--- a/cpp/src/arrow/datum.cc
+++ b/cpp/src/arrow/datum.cc
@@ -68,6 +68,8 @@ Datum::Datum(int64_t value) : value(std::make_shared<Int64Scalar>(value)) {}
 Datum::Datum(uint64_t value) : value(std::make_shared<UInt64Scalar>(value)) {}
 Datum::Datum(float value) : value(std::make_shared<FloatScalar>(value)) {}
 Datum::Datum(double value) : value(std::make_shared<DoubleScalar>(value)) {}
+Datum::Datum(std::complex<float> value) : value(std::make_shared<ComplexFloatScalar>(std::move(value))) {}
+Datum::Datum(std::complex<double> value) : value(std::make_shared<ComplexDoubleScalar>(std::move(value))) {}
 Datum::Datum(std::string value)
     : value(std::make_shared<StringScalar>(std::move(value))) {}
 Datum::Datum(const char* value) : value(std::make_shared<StringScalar>(value)) {}
diff --git a/cpp/src/arrow/datum.h b/cpp/src/arrow/datum.h
index 6ba6af7f79e..202bd220e4a 100644
--- a/cpp/src/arrow/datum.h
+++ b/cpp/src/arrow/datum.h
@@ -163,6 +163,8 @@ struct ARROW_EXPORT Datum {
   explicit Datum(uint64_t value);
   explicit Datum(float value);
   explicit Datum(double value);
+  explicit Datum(std::complex<float> value);
+  explicit Datum(std::complex<double> value);
   explicit Datum(std::string value);
   explicit Datum(const char* value);
 
diff --git a/cpp/src/arrow/ipc/metadata_internal.cc b/cpp/src/arrow/ipc/metadata_internal.cc
index 4b332bd9e1e..1041e581c55 100644
--- a/cpp/src/arrow/ipc/metadata_internal.cc
+++ b/cpp/src/arrow/ipc/metadata_internal.cc
@@ -153,6 +153,19 @@ Status FloatFromFlatbuffer(const flatbuf::FloatingPoint* float_data,
   return Status::OK();
 }
 
+Status ComplexFromFlatbuffer(const flatbuf::Complex* complex_data,
+                             std::shared_ptr<DataType>* out) {
+  if(complex_data->precision() == flatbuf::Precision::SINGLE) {
+    *out = complex64();
+  } else if(complex_data->precision() == flatbuf::Precision::DOUBLE) {
+    *out = complex128();
+  } else {
+    return Status::NotImplemented("Invalid Complex Data precision");
+  }
+
+  return Status::OK();
+}
+
 Offset IntToFlatbuffer(FBB& fbb, int bitWidth, bool is_signed) {
   return flatbuf::CreateInt(fbb, bitWidth, is_signed).Union();
 }
@@ -161,6 +174,10 @@ Offset FloatToFlatbuffer(FBB& fbb, flatbuf::Precision precision) {
   return flatbuf::CreateFloatingPoint(fbb, precision).Union();
 }
 
+Offset ComplexToFlatbuffer(FBB& fbb, flatbuf::Precision precision) {
+  return flatbuf::CreateComplex(fbb, precision).Union(); 
+}
+
 // ----------------------------------------------------------------------
 // Union implementation
 
@@ -250,6 +267,9 @@ Status ConcreteTypeFromFlatbuffer(flatbuf::Type type, const void* type_data,
     case flatbuf::Type::FloatingPoint:
       return FloatFromFlatbuffer(static_cast<const flatbuf::FloatingPoint*>(type_data),
                                  out);
+    case flatbuf::Type::Complex:
+      return ComplexFromFlatbuffer(static_cast<const flatbuf::Complex*>(type_data),
+                                   out);
     case flatbuf::Type::Binary:
       *out = binary();
       return Status::OK();
@@ -417,6 +437,14 @@ Status TensorTypeToFlatbuffer(FBB& fbb, const DataType& type, flatbuf::Type* out
       *out_type = flatbuf::Type::FloatingPoint;
       *offset = FloatToFlatbuffer(fbb, flatbuf::Precision::DOUBLE);
       break;
+    case Type::COMPLEX_FLOAT:
+      *out_type = flatbuf::Type::Complex;
+      *offset = ComplexToFlatbuffer(fbb, flatbuf::Precision::SINGLE);
+      break;
+    case Type::COMPLEX_DOUBLE:
+      *out_type = flatbuf::Type::Complex;
+      *offset = ComplexToFlatbuffer(fbb, flatbuf::Precision::DOUBLE);
+      break;
     default:
       *out_type = flatbuf::Type::NONE;  // Make clang-tidy happy
       return Status::NotImplemented("Unable to convert type: ", type.ToString());
@@ -503,6 +531,18 @@ class FieldToFlatbufferVisitor {
     return Status::OK();
   }
 
+  Status Visit(const ComplexFloatType& type) {
+    fb_type_ = flatbuf::Type::Complex;
+    type_offset_ = ComplexToFlatbuffer(fbb_, flatbuf::Precision::SINGLE);
+    return Status::OK();
+  }
+
+  Status Visit(const ComplexDoubleType& type) {
+    fb_type_ = flatbuf::Type::Complex;
+    type_offset_ = ComplexToFlatbuffer(fbb_, flatbuf::Precision::DOUBLE);
+    return Status::OK();
+  }
+
   Status Visit(const FixedSizeBinaryType& type) {
     const auto& fw_type = checked_cast<const FixedSizeBinaryType&>(type);
     fb_type_ = flatbuf::Type::FixedSizeBinary;
diff --git a/cpp/src/arrow/pretty_print.cc b/cpp/src/arrow/pretty_print.cc
index 8d1c16e0ed6..8b0cabed0be 100644
--- a/cpp/src/arrow/pretty_print.cc
+++ b/cpp/src/arrow/pretty_print.cc
@@ -166,6 +166,15 @@ class ArrayPrinter : public PrettyPrinter {
     return Status::OK();
   }
 
+  template <typename T>
+  enable_if_complex<typename T::TypeClass, Status> WriteDataValues(
+      const T& array) {
+    const auto data = array.raw_values();
+    WriteValues(array, [&](int64_t i) { (*sink_) << data[i]; });
+    return Status::OK();
+  }
+
+
   template <typename T>
   enable_if_date<typename T::TypeClass, Status> WriteDataValues(const T& array) {
     const auto data = array.raw_values();
diff --git a/cpp/src/arrow/python/arrow_to_pandas.cc b/cpp/src/arrow/python/arrow_to_pandas.cc
index cc386f589a7..7dbddd3ae3f 100644
--- a/cpp/src/arrow/python/arrow_to_pandas.cc
+++ b/cpp/src/arrow/python/arrow_to_pandas.cc
@@ -167,6 +167,8 @@ static inline bool ListTypeSupported(const DataType& type) {
     case Type::UINT64:
     case Type::FLOAT:
     case Type::DOUBLE:
+    case Type::COMPLEX_FLOAT:
+    case Type::COMPLEX_DOUBLE:
     case Type::DECIMAL128:
     case Type::DECIMAL256:
     case Type::BINARY:
@@ -1168,6 +1170,7 @@ struct ObjectWriterVisitor {
 
   template <typename Type>
   enable_if_t<is_floating_type<Type>::value ||
+              is_complex_type<Type>::value ||
                   std::is_same<DictionaryType, Type>::value ||
                   std::is_same<DurationType, Type>::value ||
                   std::is_same<ExtensionType, Type>::value ||
diff --git a/cpp/src/arrow/python/type_traits.h b/cpp/src/arrow/python/type_traits.h
index a941577f765..be270d1be4c 100644
--- a/cpp/src/arrow/python/type_traits.h
+++ b/cpp/src/arrow/python/type_traits.h
@@ -126,6 +126,43 @@ struct npy_traits<NPY_FLOAT64> {
   static inline bool isnull(double v) { return v != v; }
 };
 
+template <>
+struct npy_traits<NPY_COMPLEX64> {
+  typedef std::complex<float> value_type;
+  using TypeClass = ComplexFloatType;
+  using BuilderClass = ComplexFloatBuilder;
+
+  // We need to use quiet_NaN here instead of the NAN macro as on Windows
+  // the NAN macro leads to "division-by-zero" compile-time error with clang.
+  static constexpr std::complex<float> na_sentinel = {
+    std::numeric_limits<float>::quiet_NaN(),
+    std::numeric_limits<float>::quiet_NaN()
+  };
+
+  static constexpr bool supports_nulls = true;
+
+  static inline bool isnull(const std::complex<float> & v) { return v != v; }
+};
+
+template <>
+struct npy_traits<NPY_COMPLEX128> {
+  typedef std::complex<double> value_type;
+  using TypeClass = ComplexDoubleType;
+  using BuilderClass = ComplexDoubleBuilder;
+
+  // We need to use quiet_NaN here instead of the NAN macro as on Windows
+  // the NAN macro leads to "division-by-zero" compile-time error with clang.
+  static constexpr std::complex<double> na_sentinel = {
+    std::numeric_limits<double>::quiet_NaN(),
+    std::numeric_limits<double>::quiet_NaN()
+  };
+
+  static constexpr bool supports_nulls = true;
+
+  static inline bool isnull(const std::complex<double> & v) { return v != v; }
+};
+
+
 template <>
 struct npy_traits<NPY_DATETIME> {
   typedef int64_t value_type;
diff --git a/cpp/src/arrow/scalar.cc b/cpp/src/arrow/scalar.cc
index 56a36114e49..0f55bbab840 100644
--- a/cpp/src/arrow/scalar.cc
+++ b/cpp/src/arrow/scalar.cc
@@ -60,6 +60,10 @@ struct ScalarHashImpl {
 
   Status Visit(const BaseBinaryScalar& s) { return BufferHash(*s.value); }
 
+  Status Visit(const ComplexFloatScalar& s) {
+    return StdHash(s.value.real()) & StdHash(s.value.imag());
+  }
+
   template <typename T>
   Status Visit(const TemporalScalar<T>& s) {
     return ValueHash(s);
@@ -106,6 +110,15 @@ struct ScalarHashImpl {
     return Status::OK();
   }
 
+  template <typename T>
+  Status StdHash(const std::complex<T>& t)
+  {
+    static std::hash<T> hash;
+    hash_ ^= hash(t.real());
+    hash_ ^= hash(t.imag());
+    return Status::OK();
+  }
+
   template <typename S>
   Status ValueHash(const S& s) {
     return StdHash(s.value);
@@ -412,12 +425,32 @@ std::shared_ptr<Buffer> FormatToBuffer(Formatter&& formatter, const ScalarType&
   });
 }
 
+// complex numeric to real numeric
+// template <typename From, typename To>
+// enable_if_t<is_complex_type<From>::value && !is_complex_type<To>::value, Status>
+// CastImpl(const NumericScalar<From>& from, NumericScalar<To>* to) {
+//   return Status::NotImplemented("casting complex ", *from.type, " to real ", *to->type);
+// }
+
 // error fallback
 Status CastImpl(const Scalar& from, Scalar* to) {
   return Status::NotImplemented("casting scalars of type ", *from.type, " to type ",
                                 *to->type);
 }
 
+template <typename To>
+Status CastImpl(const NumericScalar<ComplexFloatType>& from, NumericScalar<To>* to) {
+  return Status::NotImplemented("casting complex type ", *from.type, " to real type ",
+                                *to->type);
+}
+
+template <typename To>
+Status CastImpl(const NumericScalar<ComplexDoubleType>& from, NumericScalar<To>* to) {
+  return Status::NotImplemented("casting complex type ", *from.type, " to real type ",
+                                *to->type);
+}
+
+
 // numeric to numeric
 template <typename From, typename To>
 Status CastImpl(const NumericScalar<From>& from, NumericScalar<To>* to) {
@@ -425,6 +458,7 @@ Status CastImpl(const NumericScalar<From>& from, NumericScalar<To>* to) {
   return Status::OK();
 }
 
+
 // numeric to boolean
 template <typename T>
 Status CastImpl(const NumericScalar<T>& from, BooleanScalar* to) {
@@ -443,7 +477,8 @@ Status CastImpl(const BooleanScalar& from, NumericScalar<T>* to) {
 // numeric to temporal
 template <typename From, typename To>
 typename std::enable_if<std::is_base_of<TemporalType, To>::value &&
-                            !std::is_same<DayTimeIntervalType, To>::value,
+                            !std::is_same<DayTimeIntervalType, To>::value &&
+                            !is_complex_type<From>::value,
                         Status>::type
 CastImpl(const NumericScalar<From>& from, TemporalScalar<To>* to) {
   to->value = static_cast<typename To::c_type>(from.value);
@@ -453,7 +488,8 @@ CastImpl(const NumericScalar<From>& from, TemporalScalar<To>* to) {
 // temporal to numeric
 template <typename From, typename To>
 typename std::enable_if<std::is_base_of<TemporalType, From>::value &&
-                            !std::is_same<DayTimeIntervalType, From>::value,
+                            !std::is_same<DayTimeIntervalType, From>::value &&
+                            !is_complex_type<From>::value,
                         Status>::type
 CastImpl(const TemporalScalar<From>& from, NumericScalar<To>* to) {
   to->value = static_cast<typename To::c_type>(from.value);
diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h
index 24744859686..605417d9075 100644
--- a/cpp/src/arrow/scalar.h
+++ b/cpp/src/arrow/scalar.h
@@ -204,6 +204,15 @@ struct ARROW_EXPORT DoubleScalar : public NumericScalar<DoubleType> {
   using NumericScalar<DoubleType>::NumericScalar;
 };
 
+struct ARROW_EXPORT ComplexFloatScalar : public NumericScalar<ComplexFloatType> {
+  using NumericScalar<ComplexFloatType>::NumericScalar;
+};
+
+struct ARROW_EXPORT ComplexDoubleScalar : public NumericScalar<ComplexDoubleType> {
+  using NumericScalar<ComplexDoubleType>::NumericScalar;
+};
+
+
 struct ARROW_EXPORT BaseBinaryScalar : public Scalar {
   using Scalar::Scalar;
   using ValueType = std::shared_ptr<Buffer>;
diff --git a/cpp/src/arrow/tensor.cc b/cpp/src/arrow/tensor.cc
index d591bacff02..c77c368ab30 100644
--- a/cpp/src/arrow/tensor.cc
+++ b/cpp/src/arrow/tensor.cc
@@ -297,13 +297,24 @@ int64_t StridedTensorCountNonZero(int dim_index, int64_t offset, const Tensor& t
 }
 
 template <typename TYPE>
-int64_t ContiguousTensorCountNonZero(const Tensor& tensor) {
+enable_if_t<!is_complex_type<TYPE>::value, int64_t>
+ContiguousTensorCountNonZero(const Tensor& tensor) {
   using c_type = typename TYPE::c_type;
   auto* data = reinterpret_cast<c_type const*>(tensor.raw_data());
   return std::count_if(data, data + tensor.size(),
                        [](c_type const& x) { return x != 0; });
 }
 
+template <typename TYPE>
+enable_if_t<is_complex_type<TYPE>::value, int64_t>
+ContiguousTensorCountNonZero(const Tensor& tensor) {
+  using c_type = typename TYPE::c_type;
+  auto* data = reinterpret_cast<c_type const*>(tensor.raw_data());
+  return std::count_if(data, data + tensor.size(),
+                       [](c_type const& x) { return x != c_type(0, 0); });
+}
+
+
 template <typename TYPE>
 inline int64_t TensorCountNonZero(const Tensor& tensor) {
   if (tensor.is_contiguous()) {
diff --git a/cpp/src/arrow/testing/gtest_util.cc b/cpp/src/arrow/testing/gtest_util.cc
index ea6edb0258e..3331885f284 100644
--- a/cpp/src/arrow/testing/gtest_util.cc
+++ b/cpp/src/arrow/testing/gtest_util.cc
@@ -73,6 +73,8 @@ std::vector<Type::type> AllTypeIds() {
           Type::HALF_FLOAT,
           Type::FLOAT,
           Type::DOUBLE,
+          Type::COMPLEX_FLOAT,
+          Type::COMPLEX_DOUBLE,
           Type::DECIMAL128,
           Type::DECIMAL256,
           Type::DATE32,
diff --git a/cpp/src/arrow/testing/json_internal.cc b/cpp/src/arrow/testing/json_internal.cc
index e6a5723840a..d1231d866fa 100644
--- a/cpp/src/arrow/testing/json_internal.cc
+++ b/cpp/src/arrow/testing/json_internal.cc
@@ -374,6 +374,10 @@ class SchemaWriter {
     return WritePrimitive("floatingpoint", type);
   }
 
+  Status Visit(const ComplexType& type) {
+    return WritePrimitive("complex", type);
+  }
+
   Status Visit(const DateType& type) { return WritePrimitive("date", type); }
   Status Visit(const TimeType& type) { return WritePrimitive("time", type); }
   Status Visit(const StringType& type) { return WriteVarBytes("utf8", type); }
@@ -516,6 +520,20 @@ class ArrayWriter {
     }
   }
 
+  template <typename ArrayType>
+  enable_if_complex<typename ArrayType::TypeClass> WriteDataValues(
+    const ArrayType& arr) {
+    static const std::string null_string = "0";
+    const auto data = arr.raw_values();
+    for (int64_t i = 0; i < arr.length(); ++i) {
+      if (arr.IsValid(i)) {
+        writer_->Double(data[i].real());
+      } else {
+        WriteRawNumber(null_string);
+      }
+    }
+  }
+
   // Binary, encode to hexadecimal.
   template <typename ArrayType>
   enable_if_binary_like<typename ArrayType::TypeClass> WriteDataValues(
@@ -1193,6 +1211,12 @@ enable_if_physical_floating_point<T, typename T::c_type> UnboxValue(
   return static_cast<typename T::c_type>(val.GetDouble());
 }
 
+template <typename T>
+enable_if_complex<T, typename T::c_type> UnboxValue(
+  const rj::Value& val) {
+    return typename T::c_type();
+}
+
 class ArrayReader {
  public:
   ArrayReader(const RjObject& obj, MemoryPool* pool, const std::shared_ptr<Field>& field)
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 41914f43663..10cce1ec420 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -130,6 +130,8 @@ std::string ToString(Type::type id) {
     TO_STRING_CASE(HALF_FLOAT)
     TO_STRING_CASE(FLOAT)
     TO_STRING_CASE(DOUBLE)
+    TO_STRING_CASE(COMPLEX_FLOAT)
+    TO_STRING_CASE(COMPLEX_DOUBLE)
     TO_STRING_CASE(DECIMAL128)
     TO_STRING_CASE(DECIMAL256)
     TO_STRING_CASE(DATE32)
@@ -399,6 +401,15 @@ FloatingPointType::Precision DoubleType::precision() const {
   return FloatingPointType::DOUBLE;
 }
 
+ComplexFloatType::Precision ComplexFloatType::precision() const {
+  return ComplexFloatType::SINGLE;
+}
+
+ComplexFloatType::Precision ComplexDoubleType::precision() const {
+  return ComplexFloatType::DOUBLE;
+}
+
+
 std::string ListType::ToString() const {
   std::stringstream s;
   s << "list<" << value_field()->ToString() << ">";
@@ -1930,6 +1941,8 @@ PARAMETER_LESS_FINGERPRINT(UInt64)
 PARAMETER_LESS_FINGERPRINT(HalfFloat)
 PARAMETER_LESS_FINGERPRINT(Float)
 PARAMETER_LESS_FINGERPRINT(Double)
+PARAMETER_LESS_FINGERPRINT(ComplexFloat)
+PARAMETER_LESS_FINGERPRINT(ComplexDouble)
 PARAMETER_LESS_FINGERPRINT(Binary)
 PARAMETER_LESS_FINGERPRINT(LargeBinary)
 PARAMETER_LESS_FINGERPRINT(String)
@@ -2099,6 +2112,8 @@ TYPE_FACTORY(uint64, UInt64Type)
 TYPE_FACTORY(float16, HalfFloatType)
 TYPE_FACTORY(float32, FloatType)
 TYPE_FACTORY(float64, DoubleType)
+TYPE_FACTORY(complex64, ComplexFloatType)
+TYPE_FACTORY(complex128, ComplexDoubleType)
 TYPE_FACTORY(utf8, StringType)
 TYPE_FACTORY(large_utf8, LargeStringType)
 TYPE_FACTORY(binary, BinaryType)
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index b933da66089..cd5783e220c 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -19,6 +19,7 @@
 
 #include <atomic>
 #include <climits>
+#include <complex>
 #include <cstdint>
 #include <iosfwd>
 #include <limits>
@@ -212,6 +213,9 @@ class ARROW_EXPORT PrimitiveCType : public FixedWidthType {
 class ARROW_EXPORT NumberType : public PrimitiveCType {
  public:
   using PrimitiveCType::PrimitiveCType;
+
+  static constexpr bool is_utf8 = false;
+
 };
 
 /// \brief Base class for all integral data types
@@ -229,6 +233,14 @@ class ARROW_EXPORT FloatingPointType : public NumberType {
   virtual Precision precision() const = 0;
 };
 
+/// \brief Base class for all complex-number data types
+class ARROW_EXPORT ComplexType : public NumberType {
+ public:
+  using NumberType::NumberType;
+  enum Precision { SINGLE, DOUBLE };
+  virtual Precision precision() const = 0;
+};
+
 /// \brief Base class for all parametric data types
 class ParametricType {};
 
@@ -549,6 +561,33 @@ class ARROW_EXPORT DoubleType
   std::string ComputeFingerprint() const override;
 };
 
+/// Concrete type class for 32-bit complex-number data (C "float complex")
+/// NOTE(sjperkins) The c-type "float complex" is not accepted as a
+/// template parameter, so we use the C++ type instead
+class ARROW_EXPORT ComplexFloatType
+  : public detail::CTypeImpl<ComplexFloatType, ComplexType, Type::COMPLEX_FLOAT, std::complex<float>> {
+public:
+  Precision precision() const override;
+  static constexpr const char* type_name() { return "complexfloat"; }
+
+protected:
+  std::string ComputeFingerprint() const override;
+};
+
+/// Concrete type class for 32-bit complex-number data (C "double complex")
+/// NOTE(sjperkins) The c-type "double complex" is not accepted as a
+/// template parameter, so we use the C++ type instead
+class ARROW_EXPORT ComplexDoubleType
+  : public detail::CTypeImpl<ComplexDoubleType, ComplexType, Type::COMPLEX_DOUBLE, std::complex<double>> {
+public:
+  Precision precision() const override;
+  static constexpr const char* type_name() { return "complexdouble"; }
+
+protected:
+  std::string ComputeFingerprint() const override;
+};
+
+
 /// \brief Base class for all variable-size list data types
 class ARROW_EXPORT BaseListType : public NestedType {
  public:
diff --git a/cpp/src/arrow/type_fwd.h b/cpp/src/arrow/type_fwd.h
index 7e564106bbe..e4662be70c8 100644
--- a/cpp/src/arrow/type_fwd.h
+++ b/cpp/src/arrow/type_fwd.h
@@ -206,6 +206,8 @@ _NUMERIC_TYPE_DECL(UInt64)
 _NUMERIC_TYPE_DECL(HalfFloat)
 _NUMERIC_TYPE_DECL(Float)
 _NUMERIC_TYPE_DECL(Double)
+_NUMERIC_TYPE_DECL(ComplexFloat)
+_NUMERIC_TYPE_DECL(ComplexDouble)
 
 #undef _NUMERIC_TYPE_DECL
 
@@ -394,6 +396,12 @@ struct Type {
     /// Like LIST, but with 64-bit offsets
     LARGE_LIST,
 
+    /// 8-byte Complex Number
+    COMPLEX_FLOAT,
+
+    /// 16-byte Complex Number
+    COMPLEX_DOUBLE,
+
     // Leave this at the end
     MAX_ID
   };
@@ -430,6 +438,10 @@ std::shared_ptr<DataType> ARROW_EXPORT float16();
 std::shared_ptr<DataType> ARROW_EXPORT float32();
 /// \brief Return a DoubleType instance
 std::shared_ptr<DataType> ARROW_EXPORT float64();
+/// \brief Return a ComplexFloatType instance
+std::shared_ptr<DataType> ARROW_EXPORT complex64();
+/// \brief Return a ComplexDoubleType instance
+std::shared_ptr<DataType> ARROW_EXPORT complex128();
 /// \brief Return a StringType instance
 std::shared_ptr<DataType> ARROW_EXPORT utf8();
 /// \brief Return a LargeStringType instance
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index 86664bbb162..fcb515ae76f 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <complex>
+#include <complex>
 #include <memory>
 #include <string>
 #include <type_traits>
@@ -53,6 +55,8 @@ TYPE_ID_TRAIT(UINT64, UInt64Type)
 TYPE_ID_TRAIT(HALF_FLOAT, HalfFloatType)
 TYPE_ID_TRAIT(FLOAT, FloatType)
 TYPE_ID_TRAIT(DOUBLE, DoubleType)
+TYPE_ID_TRAIT(COMPLEX_FLOAT, ComplexFloatType)
+TYPE_ID_TRAIT(COMPLEX_DOUBLE, ComplexDoubleType)
 TYPE_ID_TRAIT(STRING, StringType)
 TYPE_ID_TRAIT(BINARY, BinaryType)
 TYPE_ID_TRAIT(LARGE_STRING, LargeStringType)
@@ -157,6 +161,8 @@ PRIMITIVE_TYPE_TRAITS_DEF(uint64_t, UInt64, uint64)
 PRIMITIVE_TYPE_TRAITS_DEF(int64_t, Int64, int64)
 PRIMITIVE_TYPE_TRAITS_DEF(float, Float, float32)
 PRIMITIVE_TYPE_TRAITS_DEF(double, Double, float64)
+PRIMITIVE_TYPE_TRAITS_DEF(std::complex<float>, ComplexFloat, complex64)
+PRIMITIVE_TYPE_TRAITS_DEF(std::complex<double>, ComplexDouble, complex128)
 
 #undef PRIMITIVE_TYPE_TRAITS_DEF
 #undef PRIMITIVE_TYPE_TRAITS_DEF_
@@ -528,6 +534,12 @@ using is_half_float_type = std::is_same<HalfFloatType, T>;
 template <typename T, typename R = void>
 using enable_if_half_float = enable_if_t<is_half_float_type<T>::value, R>;
 
+template <typename T>
+using is_complex_type = std::is_base_of<ComplexType, T>;
+
+template <typename T, typename R = void>
+using enable_if_complex = enable_if_t<is_complex_type<T>::value, R>;
+
 // Binary Types
 
 // Base binary refers to Binary/LargeBinary/String/LargeString
diff --git a/cpp/src/arrow/util/endian.h b/cpp/src/arrow/util/endian.h
index 0cb2e44d275..b38c2f95d09 100644
--- a/cpp/src/arrow/util/endian.h
+++ b/cpp/src/arrow/util/endian.h
@@ -52,6 +52,8 @@
 #define ARROW_BYTE_SWAP32 __builtin_bswap32
 #endif
 
+#include <complex>
+
 #include "arrow/util/type_traits.h"
 #include "arrow/util/ubsan.h"
 
@@ -89,6 +91,15 @@ static inline float ByteSwap(float value) {
   return util::SafeCopy<float>(swapped);
 }
 
+static inline std::complex<float> ByteSwap(std::complex<float> value) {
+  return value;
+}
+
+static inline std::complex<double> ByteSwap(std::complex<double> value) {
+  return value;
+}
+
+
 // Write the swapped bytes into dst. Src and dst cannot overlap.
 static inline void ByteSwap(void* dst, const void* src, int len) {
   switch (len) {
diff --git a/cpp/src/arrow/util/tdigest.h b/cpp/src/arrow/util/tdigest.h
index ae42ce48e7d..1d6dce2cbb7 100644
--- a/cpp/src/arrow/util/tdigest.h
+++ b/cpp/src/arrow/util/tdigest.h
@@ -23,6 +23,7 @@
 #pragma once
 
 #include <cmath>
+#include <complex>
 #include <memory>
 #include <vector>
 
@@ -69,6 +70,16 @@ class ARROW_EXPORT TDigest {
     if (!std::isnan(value)) Add(value);
   }
 
+  template <typename T>
+  void NanAdd(const std::complex<T> & value) {
+      // NOTE(sjperkins)
+      // Adding magnitude of complex number to digest may be dubious
+      // double check this.
+      if (!std::isnan(value.real()) && !std::isnan(value.imag())) {
+        Add(std::abs(value));
+      }
+  }
+
   template <typename T>
   typename std::enable_if<std::is_integral<T>::value>::type NanAdd(T value) {
     Add(static_cast<double>(value));
diff --git a/cpp/src/arrow/util/value_parsing.h b/cpp/src/arrow/util/value_parsing.h
index 00295d1b51f..6d3c2cbd700 100644
--- a/cpp/src/arrow/util/value_parsing.h
+++ b/cpp/src/arrow/util/value_parsing.h
@@ -708,6 +708,31 @@ struct StringConverter<DurationType>
   using StringToSignedIntConverterMixin<DurationType>::StringToSignedIntConverterMixin;
 };
 
+template <typename COMPLEX_TYPE>
+struct StringConverter<COMPLEX_TYPE, enable_if_complex<COMPLEX_TYPE>> {
+  using value_type = typename COMPLEX_TYPE::c_type;
+
+  static bool Convert(const COMPLEX_TYPE& type, const char* s, size_t length,
+                      value_type* out) {
+    //0+0j
+    if(length < 4) {
+      return false;
+    }
+
+    if(s[length - 1] != 'j') {
+      return false;
+    }
+
+    std::size_t i = 0;
+
+    while(i < length) {
+    }
+
+    return true;
+
+  }
+};
+
 template <typename DATE_TYPE>
 struct StringConverter<DATE_TYPE, enable_if_date<DATE_TYPE>> {
   using value_type = typename DATE_TYPE::c_type;
diff --git a/cpp/src/arrow/visitor.cc b/cpp/src/arrow/visitor.cc
index 851785081c7..e88495fd2ec 100644
--- a/cpp/src/arrow/visitor.cc
+++ b/cpp/src/arrow/visitor.cc
@@ -45,6 +45,8 @@ ARRAY_VISITOR_DEFAULT(UInt64Array)
 ARRAY_VISITOR_DEFAULT(HalfFloatArray)
 ARRAY_VISITOR_DEFAULT(FloatArray)
 ARRAY_VISITOR_DEFAULT(DoubleArray)
+ARRAY_VISITOR_DEFAULT(ComplexFloatArray)
+ARRAY_VISITOR_DEFAULT(ComplexDoubleArray)
 ARRAY_VISITOR_DEFAULT(BinaryArray)
 ARRAY_VISITOR_DEFAULT(StringArray)
 ARRAY_VISITOR_DEFAULT(LargeBinaryArray)
@@ -93,6 +95,8 @@ TYPE_VISITOR_DEFAULT(UInt64Type)
 TYPE_VISITOR_DEFAULT(HalfFloatType)
 TYPE_VISITOR_DEFAULT(FloatType)
 TYPE_VISITOR_DEFAULT(DoubleType)
+TYPE_VISITOR_DEFAULT(ComplexFloatType)
+TYPE_VISITOR_DEFAULT(ComplexDoubleType)
 TYPE_VISITOR_DEFAULT(StringType)
 TYPE_VISITOR_DEFAULT(BinaryType)
 TYPE_VISITOR_DEFAULT(LargeStringType)
@@ -142,6 +146,8 @@ SCALAR_VISITOR_DEFAULT(UInt64Scalar)
 SCALAR_VISITOR_DEFAULT(HalfFloatScalar)
 SCALAR_VISITOR_DEFAULT(FloatScalar)
 SCALAR_VISITOR_DEFAULT(DoubleScalar)
+SCALAR_VISITOR_DEFAULT(ComplexFloatScalar)
+SCALAR_VISITOR_DEFAULT(ComplexDoubleScalar)
 SCALAR_VISITOR_DEFAULT(StringScalar)
 SCALAR_VISITOR_DEFAULT(BinaryScalar)
 SCALAR_VISITOR_DEFAULT(LargeStringScalar)
diff --git a/cpp/src/arrow/visitor.h b/cpp/src/arrow/visitor.h
index 0382e461199..508dad08482 100644
--- a/cpp/src/arrow/visitor.h
+++ b/cpp/src/arrow/visitor.h
@@ -40,6 +40,8 @@ class ARROW_EXPORT ArrayVisitor {
   virtual Status Visit(const HalfFloatArray& array);
   virtual Status Visit(const FloatArray& array);
   virtual Status Visit(const DoubleArray& array);
+  virtual Status Visit(const ComplexFloatArray& array);
+  virtual Status Visit(const ComplexDoubleArray& array);
   virtual Status Visit(const StringArray& array);
   virtual Status Visit(const BinaryArray& array);
   virtual Status Visit(const LargeStringArray& array);
@@ -83,6 +85,8 @@ class ARROW_EXPORT TypeVisitor {
   virtual Status Visit(const HalfFloatType& type);
   virtual Status Visit(const FloatType& type);
   virtual Status Visit(const DoubleType& type);
+  virtual Status Visit(const ComplexFloatType& type);
+  virtual Status Visit(const ComplexDoubleType& type);
   virtual Status Visit(const StringType& type);
   virtual Status Visit(const BinaryType& type);
   virtual Status Visit(const LargeStringType& type);
@@ -126,6 +130,8 @@ class ARROW_EXPORT ScalarVisitor {
   virtual Status Visit(const HalfFloatScalar& scalar);
   virtual Status Visit(const FloatScalar& scalar);
   virtual Status Visit(const DoubleScalar& scalar);
+  virtual Status Visit(const ComplexFloatScalar& scalar);
+  virtual Status Visit(const ComplexDoubleScalar& scalar);
   virtual Status Visit(const StringScalar& scalar);
   virtual Status Visit(const BinaryScalar& scalar);
   virtual Status Visit(const LargeStringScalar& scalar);
diff --git a/cpp/src/arrow/visitor_inline.h b/cpp/src/arrow/visitor_inline.h
index 132c35aeaa1..e37221e1316 100644
--- a/cpp/src/arrow/visitor_inline.h
+++ b/cpp/src/arrow/visitor_inline.h
@@ -48,7 +48,9 @@ namespace arrow {
   ARROW_GENERATE_FOR_ALL_INTEGER_TYPES(ACTION);      \
   ACTION(HalfFloat);                                 \
   ACTION(Float);                                     \
-  ACTION(Double)
+  ACTION(Double);                                    \
+  ACTION(ComplexFloat);                              \
+  ACTION(ComplexDouble)                              
 
 #define ARROW_GENERATE_FOR_ALL_TYPES(ACTION)    \
   ACTION(Null);                                 \
diff --git a/cpp/src/generated/File_generated.h b/cpp/src/generated/File_generated.h
index 06953c4a040..71a174dfcca 100644
--- a/cpp/src/generated/File_generated.h
+++ b/cpp/src/generated/File_generated.h
@@ -26,8 +26,12 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Block FLATBUFFERS_FINAL_CLASS {
   int64_t bodyLength_;
 
  public:
-  Block() {
-    memset(static_cast<void *>(this), 0, sizeof(Block));
+  Block()
+      : offset_(0),
+        metaDataLength_(0),
+        padding0__(0),
+        bodyLength_(0) {
+    (void)padding0__;
   }
   Block(int64_t _offset, int32_t _metaDataLength, int64_t _bodyLength)
       : offset_(flatbuffers::EndianScalar(_offset)),
@@ -119,7 +123,6 @@ 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 822bec9952b..3f863c5a068 100644
--- a/cpp/src/generated/Message_generated.h
+++ b/cpp/src/generated/Message_generated.h
@@ -6,9 +6,9 @@
 
 #include "flatbuffers/flatbuffers.h"
 
-#include "Schema_generated.h"
-#include "SparseTensor_generated.h"
 #include "Tensor_generated.h"
+#include "SparseTensor_generated.h"
+#include "Schema_generated.h"
 
 namespace org {
 namespace apache {
@@ -179,7 +179,7 @@ bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const flatbuffer
 /// Metadata about a field at some level of a nested type tree (but not
 /// its children).
 ///
-/// For example, a List<Int16> with values [[1, 2, 3], null, [4], [5, 6], null]
+/// For example, a List<Int16> with values `[[1, 2, 3], null, [4], [5, 6], null]`
 /// would have {length: 5, null_count: 2} for its List node, and {length: 6,
 /// null_count: 0} for its Int16 node, as separate FieldNode structs
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) FieldNode FLATBUFFERS_FINAL_CLASS {
@@ -188,8 +188,9 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) FieldNode FLATBUFFERS_FINAL_CLASS {
   int64_t null_count_;
 
  public:
-  FieldNode() {
-    memset(static_cast<void *>(this), 0, sizeof(FieldNode));
+  FieldNode()
+      : length_(0),
+        null_count_(0) {
   }
   FieldNode(int64_t _length, int64_t _null_count)
       : length_(flatbuffers::EndianScalar(_length)),
@@ -248,7 +249,6 @@ 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);
@@ -332,7 +332,6 @@ struct RecordBatchBuilder {
         : 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);
@@ -422,7 +421,6 @@ 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);
@@ -539,7 +537,6 @@ 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 91e01d33758..abaf9ffe4d9 100644
--- a/cpp/src/generated/Schema_generated.h
+++ b/cpp/src/generated/Schema_generated.h
@@ -38,6 +38,9 @@ struct IntBuilder;
 struct FloatingPoint;
 struct FloatingPointBuilder;
 
+struct Complex;
+struct ComplexBuilder;
+
 struct Utf8;
 struct Utf8Builder;
 
@@ -379,11 +382,12 @@ enum class Type : uint8_t {
   LargeBinary = 19,
   LargeUtf8 = 20,
   LargeList = 21,
+  Complex = 22,
   MIN = NONE,
-  MAX = LargeList
+  MAX = Complex
 };
 
-inline const Type (&EnumValuesType())[22] {
+inline const Type (&EnumValuesType())[23] {
   static const Type values[] = {
     Type::NONE,
     Type::Null,
@@ -406,13 +410,14 @@ inline const Type (&EnumValuesType())[22] {
     Type::Duration,
     Type::LargeBinary,
     Type::LargeUtf8,
-    Type::LargeList
+    Type::LargeList,
+    Type::Complex
   };
   return values;
 }
 
 inline const char * const *EnumNamesType() {
-  static const char * const names[23] = {
+  static const char * const names[24] = {
     "NONE",
     "Null",
     "Int",
@@ -435,13 +440,14 @@ inline const char * const *EnumNamesType() {
     "LargeBinary",
     "LargeUtf8",
     "LargeList",
+    "Complex",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameType(Type e) {
-  if (flatbuffers::IsOutRange(e, Type::NONE, Type::LargeList)) return "";
+  if (flatbuffers::IsOutRange(e, Type::NONE, Type::Complex)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesType()[index];
 }
@@ -534,6 +540,10 @@ template<> struct TypeTraits<org::apache::arrow::flatbuf::LargeList> {
   static const Type enum_value = Type::LargeList;
 };
 
+template<> struct TypeTraits<org::apache::arrow::flatbuf::Complex> {
+  static const Type enum_value = Type::Complex;
+};
+
 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);
 
@@ -609,8 +619,9 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Buffer FLATBUFFERS_FINAL_CLASS {
   int64_t length_;
 
  public:
-  Buffer() {
-    memset(static_cast<void *>(this), 0, sizeof(Buffer));
+  Buffer()
+      : offset_(0),
+        length_(0) {
   }
   Buffer(int64_t _offset, int64_t _length)
       : offset_(flatbuffers::EndianScalar(_offset)),
@@ -649,7 +660,6 @@ 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);
@@ -682,7 +692,6 @@ 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);
@@ -712,7 +721,6 @@ 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);
@@ -744,7 +752,6 @@ 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);
@@ -785,7 +792,6 @@ 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);
@@ -816,10 +822,11 @@ inline flatbuffers::Offset<FixedSizeList> CreateFixedSizeList(
 /// not enforced.
 ///
 /// Map
+/// ```text
 ///   - child[0] entries: Struct
 ///     - child[0] key: K
 ///     - child[1] value: V
-///
+/// ```
 /// Neither the "entries" field nor the "key" field may be nullable.
 ///
 /// The metadata is structured so that Arrow systems without special handling
@@ -852,7 +859,6 @@ 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);
@@ -871,7 +877,7 @@ inline flatbuffers::Offset<Map> CreateMap(
 /// A union is a complex type with children in Field
 /// By default ids in the type vector refer to the offsets in the children
 /// optionally typeIds provides an indirection between the child offset and the type id
-/// for each child typeIds[offset] is the id used in the type vector
+/// for each child `typeIds[offset]` is the id used in the type vector
 struct Union FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef UnionBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -907,7 +913,6 @@ 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);
@@ -970,7 +975,6 @@ 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);
@@ -1014,7 +1018,6 @@ 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);
@@ -1030,6 +1033,47 @@ inline flatbuffers::Offset<FloatingPoint> CreateFloatingPoint(
   return builder_.Finish();
 }
 
+struct Complex FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef ComplexBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_PRECISION = 4
+  };
+  org::apache::arrow::flatbuf::Precision precision() const {
+    return static_cast<org::apache::arrow::flatbuf::Precision>(GetField<int16_t>(VT_PRECISION, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_PRECISION) &&
+           verifier.EndTable();
+  }
+};
+
+struct ComplexBuilder {
+  typedef Complex Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_precision(org::apache::arrow::flatbuf::Precision precision) {
+    fbb_.AddElement<int16_t>(Complex::VT_PRECISION, static_cast<int16_t>(precision), 0);
+  }
+  explicit ComplexBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<Complex> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Complex>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Complex> CreateComplex(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    org::apache::arrow::flatbuf::Precision precision = org::apache::arrow::flatbuf::Precision::HALF) {
+  ComplexBuilder builder_(_fbb);
+  builder_.add_precision(precision);
+  return builder_.Finish();
+}
+
 /// Unicode with UTF-8 encoding
 struct Utf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef Utf8Builder Builder;
@@ -1047,7 +1091,6 @@ 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);
@@ -1078,7 +1121,6 @@ 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);
@@ -1110,7 +1152,6 @@ 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);
@@ -1142,7 +1183,6 @@ 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);
@@ -1183,7 +1223,6 @@ 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);
@@ -1215,7 +1254,6 @@ 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);
@@ -1230,8 +1268,8 @@ inline flatbuffers::Offset<Bool> CreateBool(
 }
 
 /// Exact decimal value represented as an integer value in two's
-/// complement. Currently only 128-bit (16-byte) integers are used but this may
-/// be expanded in the future. The representation uses the endianness indicated
+/// complement. Currently only 128-bit (16-byte) and 256-bit (32-byte) integers
+/// are used. The representation uses the endianness indicated
 /// in the Schema.
 struct Decimal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef DecimalBuilder Builder;
@@ -1248,10 +1286,8 @@ struct Decimal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int32_t scale() const {
     return GetField<int32_t>(VT_SCALE, 0);
   }
-  /// Number of bits per value. The only accepted width right now is 128 but
-  /// this field exists for forward compatibility so that other bit widths may
-  /// be supported in future format versions. We use bitWidth for consistency
-  /// with Int::bitWidth.
+  /// Number of bits per value. The only accepted widths are 128 and 256.
+  /// We use bitWidth for consistency with Int::bitWidth.
   int32_t bitWidth() const {
     return GetField<int32_t>(VT_BITWIDTH, 128);
   }
@@ -1281,7 +1317,6 @@ 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);
@@ -1333,7 +1368,6 @@ 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);
@@ -1386,7 +1420,6 @@ 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);
@@ -1465,7 +1498,6 @@ 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);
@@ -1520,7 +1552,6 @@ 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);
@@ -1562,7 +1593,6 @@ 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);
@@ -1617,7 +1647,6 @@ 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);
@@ -1710,7 +1739,6 @@ 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);
@@ -1825,6 +1853,9 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::LargeList *type_as_LargeList() const {
     return type_type() == org::apache::arrow::flatbuf::Type::LargeList ? static_cast<const org::apache::arrow::flatbuf::LargeList *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::Complex *type_as_Complex() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::Complex ? static_cast<const org::apache::arrow::flatbuf::Complex *>(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);
@@ -1942,6 +1973,10 @@ template<> inline const org::apache::arrow::flatbuf::LargeList *Field::type_as<o
   return type_as_LargeList();
 }
 
+template<> inline const org::apache::arrow::flatbuf::Complex *Field::type_as<org::apache::arrow::flatbuf::Complex>() const {
+  return type_as_Complex();
+}
+
 struct FieldBuilder {
   typedef Field Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -1971,7 +2006,6 @@ 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);
@@ -2083,7 +2117,6 @@ 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);
@@ -2211,6 +2244,10 @@ inline bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type ty
       auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::LargeList *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case Type::Complex: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::Complex *>(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 ec4d414d4fe..e729dff5cb9 100644
--- a/cpp/src/generated/SparseTensor_generated.h
+++ b/cpp/src/generated/SparseTensor_generated.h
@@ -6,8 +6,8 @@
 
 #include "flatbuffers/flatbuffers.h"
 
-#include "Schema_generated.h"
 #include "Tensor_generated.h"
+#include "Schema_generated.h"
 
 namespace org {
 namespace apache {
@@ -125,22 +125,24 @@ bool VerifySparseTensorIndexVector(flatbuffers::Verifier &verifier, const flatbu
 ///
 /// For example, let X be a 2x3x4x5 tensor, and it has the following
 /// 6 non-zero values:
-///
+/// ```text
 ///   X[0, 1, 2, 0] := 1
 ///   X[1, 1, 2, 3] := 2
 ///   X[0, 2, 1, 0] := 3
 ///   X[0, 1, 3, 0] := 4
 ///   X[0, 1, 2, 1] := 5
 ///   X[1, 2, 0, 4] := 6
-///
+/// ```
 /// In COO format, the index matrix of X is the following 4x6 matrix:
-///
+/// ```text
 ///   [[0, 0, 0, 0, 1, 1],
 ///    [1, 1, 1, 2, 1, 2],
 ///    [2, 2, 3, 1, 2, 0],
 ///    [0, 1, 0, 0, 3, 4]]
-///
-/// Note that the indices are sorted in lexicographical order.
+/// ```
+/// When isCanonical is true, the indices is sorted in lexicographical order
+/// (row-major order), and it does not have duplicated entries.  Otherwise,
+/// the indices may not be sorted, or may have duplicated entries.
 struct SparseTensorIndexCOO FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef SparseTensorIndexCOOBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -162,7 +164,11 @@ struct SparseTensorIndexCOO FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   const org::apache::arrow::flatbuf::Buffer *indicesBuffer() const {
     return GetStruct<const org::apache::arrow::flatbuf::Buffer *>(VT_INDICESBUFFER);
   }
-  /// The canonicality flag
+  /// This flag is true if and only if the indices matrix is sorted in
+  /// row-major order, and does not have duplicated entries.
+  /// This sort order is the same as of Tensorflow's SparseTensor,
+  /// but it is inverse order of SciPy's canonical coo_matrix
+  /// (SciPy employs column-major order for its coo_matrix).
   bool isCanonical() const {
     return GetField<uint8_t>(VT_ISCANONICAL, 0) != 0;
   }
@@ -198,7 +204,6 @@ 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);
@@ -257,26 +262,27 @@ struct SparseMatrixIndexCSX FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   }
   /// indptrBuffer stores the location and size of indptr array that
   /// represents the range of the rows.
-  /// The i-th row spans from indptr[i] to indptr[i+1] in the data.
+  /// The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data.
   /// The length of this array is 1 + (the number of rows), and the type
   /// of index value is long.
   ///
   /// For example, let X be the following 6x4 matrix:
-  ///
+  /// ```text
   ///   X := [[0, 1, 2, 0],
   ///         [0, 0, 3, 0],
   ///         [0, 4, 0, 5],
   ///         [0, 0, 0, 0],
   ///         [6, 0, 7, 8],
   ///         [0, 9, 0, 0]].
-  ///
+  /// ```
   /// The array of non-zero values in X is:
-  ///
+  /// ```text
   ///   values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
-  ///
+  /// ```
   /// And the indptr of X is:
-  ///
+  /// ```text
   ///   indptr(X) = [0, 2, 3, 5, 5, 8, 10].
+  /// ```
   const org::apache::arrow::flatbuf::Buffer *indptrBuffer() const {
     return GetStruct<const org::apache::arrow::flatbuf::Buffer *>(VT_INDPTRBUFFER);
   }
@@ -289,9 +295,9 @@ struct SparseMatrixIndexCSX FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   /// The type of index value is long.
   ///
   /// For example, the indices of the above X is:
-  ///
+  /// ```text
   ///   indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
-  ///
+  /// ```
   /// Note that the indices are sorted in lexicographical order for each row.
   const org::apache::arrow::flatbuf::Buffer *indicesBuffer() const {
     return GetStruct<const org::apache::arrow::flatbuf::Buffer *>(VT_INDICESBUFFER);
@@ -332,7 +338,6 @@ 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);
@@ -371,7 +376,7 @@ struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
     VT_AXISORDER = 12
   };
   /// CSF is a generalization of compressed sparse row (CSR) index.
-  /// See [smith2017knl]: http://shaden.io/pub-files/smith2017knl.pdf
+  /// See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
   ///
   /// CSF index recursively compresses each dimension of a tensor into a set
   /// of prefix trees. Each path from a root to leaf forms one tensor
@@ -380,7 +385,7 @@ struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   ///
   /// For example, let X be a 2x3x4x5 tensor and let it have the following
   /// 8 non-zero values:
-  ///
+  /// ```text
   ///   X[0, 0, 0, 1] := 1
   ///   X[0, 0, 0, 2] := 2
   ///   X[0, 1, 0, 0] := 3
@@ -389,9 +394,9 @@ struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   ///   X[1, 1, 1, 0] := 6
   ///   X[1, 1, 1, 1] := 7
   ///   X[1, 1, 1, 2] := 8
-  ///
+  /// ```
   /// As a prefix tree this would be represented as:
-  ///
+  /// ```text
   ///         0          1
   ///        / \         |
   ///       0   1        1
@@ -399,24 +404,25 @@ struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   ///     0   0   1      1
   ///    /|  /|   |    /| |
   ///   1 2 0 2   0   0 1 2
+  /// ```
   /// The type of values in indptrBuffers
   const org::apache::arrow::flatbuf::Int *indptrType() const {
     return GetPointer<const org::apache::arrow::flatbuf::Int *>(VT_INDPTRTYPE);
   }
   /// indptrBuffers stores the sparsity structure.
   /// Each two consecutive dimensions in a tensor correspond to a buffer in
-  /// indptrBuffers. A pair of consecutive values at indptrBuffers[dim][i]
-  /// and indptrBuffers[dim][i + 1] signify a range of nodes in
-  /// indicesBuffers[dim + 1] who are children of indicesBuffers[dim][i] node.
+  /// indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]`
+  /// and `indptrBuffers[dim][i + 1]` signify a range of nodes in
+  /// `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]` node.
   ///
   /// For example, the indptrBuffers for the above X is:
-  ///
+  /// ```text
   ///   indptrBuffer(X) = [
   ///                       [0, 2, 3],
   ///                       [0, 1, 3, 4],
   ///                       [0, 2, 4, 5, 8]
   ///                     ].
-  ///
+  /// ```
   const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *indptrBuffers() const {
     return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_INDPTRBUFFERS);
   }
@@ -427,23 +433,23 @@ struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   /// indicesBuffers stores values of nodes.
   /// Each tensor dimension corresponds to a buffer in indicesBuffers.
   /// For example, the indicesBuffers for the above X is:
-  ///
+  /// ```text
   ///   indicesBuffer(X) = [
   ///                        [0, 1],
   ///                        [0, 1, 1],
   ///                        [0, 0, 1, 1],
   ///                        [1, 2, 0, 2, 0, 0, 1, 2]
   ///                      ].
-  ///
+  /// ```
   const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *indicesBuffers() const {
     return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_INDICESBUFFERS);
   }
   /// axisOrder stores the sequence in which dimensions were traversed to
   /// produce the prefix tree.
   /// For example, the axisOrder for the above X is:
-  ///
+  /// ```text
   ///   axisOrder(X) = [0, 1, 2, 3].
-  ///
+  /// ```
   const flatbuffers::Vector<int32_t> *axisOrder() const {
     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_AXISORDER);
   }
@@ -486,7 +492,6 @@ 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);
@@ -618,6 +623,9 @@ struct SparseTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::LargeList *type_as_LargeList() const {
     return type_type() == org::apache::arrow::flatbuf::Type::LargeList ? static_cast<const org::apache::arrow::flatbuf::LargeList *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::Complex *type_as_Complex() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::Complex ? static_cast<const org::apache::arrow::flatbuf::Complex *>(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);
@@ -748,6 +756,10 @@ template<> inline const org::apache::arrow::flatbuf::LargeList *SparseTensor::ty
   return type_as_LargeList();
 }
 
+template<> inline const org::apache::arrow::flatbuf::Complex *SparseTensor::type_as<org::apache::arrow::flatbuf::Complex>() const {
+  return type_as_Complex();
+}
+
 template<> inline const org::apache::arrow::flatbuf::SparseTensorIndexCOO *SparseTensor::sparseIndex_as<org::apache::arrow::flatbuf::SparseTensorIndexCOO>() const {
   return sparseIndex_as_SparseTensorIndexCOO();
 }
@@ -789,7 +801,6 @@ 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 062a3b91aaa..a9ad88f3aa4 100644
--- a/cpp/src/generated/Tensor_generated.h
+++ b/cpp/src/generated/Tensor_generated.h
@@ -59,7 +59,6 @@ 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);
@@ -169,6 +168,9 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::LargeList *type_as_LargeList() const {
     return type_type() == org::apache::arrow::flatbuf::Type::LargeList ? static_cast<const org::apache::arrow::flatbuf::LargeList *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::Complex *type_as_Complex() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::Complex ? static_cast<const org::apache::arrow::flatbuf::Complex *>(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);
@@ -281,6 +283,10 @@ template<> inline const org::apache::arrow::flatbuf::LargeList *Tensor::type_as<
   return type_as_LargeList();
 }
 
+template<> inline const org::apache::arrow::flatbuf::Complex *Tensor::type_as<org::apache::arrow::flatbuf::Complex>() const {
+  return type_as_Complex();
+}
+
 struct TensorBuilder {
   typedef Tensor Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -304,7 +310,6 @@ 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 b925eb2bc6a..3696188b0f5 100644
--- a/cpp/src/generated/feather_generated.h
+++ b/cpp/src/generated/feather_generated.h
@@ -324,7 +324,6 @@ 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);
@@ -387,7 +386,6 @@ 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);
@@ -442,7 +440,6 @@ 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);
@@ -487,7 +484,6 @@ 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);
@@ -527,7 +523,6 @@ 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);
@@ -635,7 +630,6 @@ 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);
@@ -745,7 +739,6 @@ 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/plasma/common_generated.h b/cpp/src/plasma/common_generated.h
index ba9ef6e72d0..f9cd881d548 100644
--- a/cpp/src/plasma/common_generated.h
+++ b/cpp/src/plasma/common_generated.h
@@ -15,22 +15,14 @@ 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) {
-  }
+  std::string object_id{};
+  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;
+  std::string digest{};
+  bool is_deletion = false;
 };
 
 struct ObjectInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -121,7 +113,6 @@ struct ObjectInfoBuilder {
         : 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);
@@ -178,7 +169,7 @@ inline flatbuffers::Offset<ObjectInfo> CreateObjectInfoDirect(
 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());
+  auto _o = std::unique_ptr<ObjectInfoT>(new ObjectInfoT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
diff --git a/cpp/src/plasma/plasma_generated.h b/cpp/src/plasma/plasma_generated.h
index 340f043bc83..171d4507db1 100644
--- a/cpp/src/plasma/plasma_generated.h
+++ b/cpp/src/plasma/plasma_generated.h
@@ -339,8 +339,17 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) PlasmaObjectSpec FLATBUFFERS_FINAL_CLASS
   int32_t padding1__;
 
  public:
-  PlasmaObjectSpec() {
-    memset(static_cast<void *>(this), 0, sizeof(PlasmaObjectSpec));
+  PlasmaObjectSpec()
+      : segment_index_(0),
+        padding0__(0),
+        data_offset_(0),
+        data_size_(0),
+        metadata_offset_(0),
+        metadata_size_(0),
+        device_num_(0),
+        padding1__(0) {
+    (void)padding0__;
+    (void)padding1__;
   }
   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)),
@@ -377,11 +386,8 @@ 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) {
-  }
+  std::string client_name{};
+  int64_t output_memory_quota = 0;
 };
 
 struct PlasmaSetOptionsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -423,7 +429,6 @@ struct PlasmaSetOptionsRequestBuilder {
         : 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);
@@ -456,10 +461,7 @@ flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequest(flatb
 
 struct PlasmaSetOptionsReplyT : public flatbuffers::NativeTable {
   typedef PlasmaSetOptionsReply TableType;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaSetOptionsReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaSetOptionsReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -492,7 +494,6 @@ struct PlasmaSetOptionsReplyBuilder {
         : 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);
@@ -512,8 +513,6 @@ flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(flatbuffe
 
 struct PlasmaGetDebugStringRequestT : public flatbuffers::NativeTable {
   typedef PlasmaGetDebugStringRequest TableType;
-  PlasmaGetDebugStringRequestT() {
-  }
 };
 
 struct PlasmaGetDebugStringRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -536,7 +535,6 @@ struct PlasmaGetDebugStringRequestBuilder {
         : 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);
@@ -554,9 +552,7 @@ flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStringReque
 
 struct PlasmaGetDebugStringReplyT : public flatbuffers::NativeTable {
   typedef PlasmaGetDebugStringReply TableType;
-  std::string debug_string;
-  PlasmaGetDebugStringReplyT() {
-  }
+  std::string debug_string{};
 };
 
 struct PlasmaGetDebugStringReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -590,7 +586,6 @@ struct PlasmaGetDebugStringReplyBuilder {
         : 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);
@@ -619,17 +614,11 @@ flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReply(f
 
 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) {
-  }
+  std::string object_id{};
+  bool evict_if_full = false;
+  uint64_t data_size = 0;
+  uint64_t metadata_size = 0;
+  int32_t device_num = 0;
 };
 
 struct PlasmaCreateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -695,7 +684,6 @@ struct PlasmaCreateRequestBuilder {
         : 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);
@@ -740,9 +728,7 @@ flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(flatbuffers::
 
 struct CudaHandleT : public flatbuffers::NativeTable {
   typedef CudaHandle TableType;
-  std::vector<uint8_t> handle;
-  CudaHandleT() {
-  }
+  std::vector<uint8_t> handle{};
 };
 
 struct CudaHandle FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -776,7 +762,6 @@ struct CudaHandleBuilder {
         : 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);
@@ -805,17 +790,12 @@ flatbuffers::Offset<CudaHandle> CreateCudaHandle(flatbuffers::FlatBufferBuilder
 
 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) {
-  }
+  std::string object_id{};
+  std::unique_ptr<plasma::flatbuf::PlasmaObjectSpec> plasma_object{};
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
+  int32_t store_fd = 0;
+  int64_t mmap_size = 0;
+  std::unique_ptr<plasma::flatbuf::CudaHandleT> ipc_handle{};
 };
 
 struct PlasmaCreateReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -890,7 +870,6 @@ struct PlasmaCreateReplyBuilder {
         : 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);
@@ -939,14 +918,11 @@ flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(flatbuffers::Flat
 
 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) {
-  }
+  std::string object_id{};
+  bool evict_if_full = false;
+  std::string data{};
+  std::string metadata{};
+  std::string digest{};
 };
 
 struct PlasmaCreateAndSealRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1015,7 +991,6 @@ struct PlasmaCreateAndSealRequestBuilder {
         : 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);
@@ -1063,10 +1038,7 @@ flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequest
 
 struct PlasmaCreateAndSealReplyT : public flatbuffers::NativeTable {
   typedef PlasmaCreateAndSealReply TableType;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaCreateAndSealReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaCreateAndSealReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1099,7 +1071,6 @@ struct PlasmaCreateAndSealReplyBuilder {
         : 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);
@@ -1119,14 +1090,11 @@ flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealReply(fla
 
 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) {
-  }
+  std::vector<std::string> object_ids{};
+  bool evict_if_full = false;
+  std::vector<std::string> data{};
+  std::vector<std::string> metadata{};
+  std::vector<std::string> digest{};
 };
 
 struct PlasmaCreateAndSealBatchRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1199,7 +1167,6 @@ struct PlasmaCreateAndSealBatchRequestBuilder {
         : 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);
@@ -1247,10 +1214,7 @@ flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBa
 
 struct PlasmaCreateAndSealBatchReplyT : public flatbuffers::NativeTable {
   typedef PlasmaCreateAndSealBatchReply TableType;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaCreateAndSealBatchReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaCreateAndSealBatchReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1283,7 +1247,6 @@ struct PlasmaCreateAndSealBatchReplyBuilder {
         : 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);
@@ -1303,9 +1266,7 @@ flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndSealBatc
 
 struct PlasmaAbortRequestT : public flatbuffers::NativeTable {
   typedef PlasmaAbortRequest TableType;
-  std::string object_id;
-  PlasmaAbortRequestT() {
-  }
+  std::string object_id{};
 };
 
 struct PlasmaAbortRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1339,7 +1300,6 @@ struct PlasmaAbortRequestBuilder {
         : 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);
@@ -1368,9 +1328,7 @@ flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(flatbuffers::Fl
 
 struct PlasmaAbortReplyT : public flatbuffers::NativeTable {
   typedef PlasmaAbortReply TableType;
-  std::string object_id;
-  PlasmaAbortReplyT() {
-  }
+  std::string object_id{};
 };
 
 struct PlasmaAbortReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1404,7 +1362,6 @@ struct PlasmaAbortReplyBuilder {
         : 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);
@@ -1433,10 +1390,8 @@ flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(flatbuffers::FlatBu
 
 struct PlasmaSealRequestT : public flatbuffers::NativeTable {
   typedef PlasmaSealRequest TableType;
-  std::string object_id;
-  std::string digest;
-  PlasmaSealRequestT() {
-  }
+  std::string object_id{};
+  std::string digest{};
 };
 
 struct PlasmaSealRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1479,7 +1434,6 @@ struct PlasmaSealRequestBuilder {
         : 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);
@@ -1513,11 +1467,8 @@ flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(flatbuffers::Flat
 
 struct PlasmaSealReplyT : public flatbuffers::NativeTable {
   typedef PlasmaSealReply TableType;
-  std::string object_id;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaSealReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  std::string object_id{};
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaSealReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1559,7 +1510,6 @@ struct PlasmaSealReplyBuilder {
         : 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);
@@ -1592,11 +1542,8 @@ flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(flatbuffers::FlatBuff
 
 struct PlasmaGetRequestT : public flatbuffers::NativeTable {
   typedef PlasmaGetRequest TableType;
-  std::vector<std::string> object_ids;
-  int64_t timeout_ms;
-  PlasmaGetRequestT()
-      : timeout_ms(0) {
-  }
+  std::vector<std::string> object_ids{};
+  int64_t timeout_ms = 0;
 };
 
 struct PlasmaGetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1639,7 +1586,6 @@ struct PlasmaGetRequestBuilder {
         : 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);
@@ -1672,13 +1618,11 @@ flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(flatbuffers::FlatBu
 
 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() {
-  }
+  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{};
 };
 
 struct PlasmaGetReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1750,7 +1694,6 @@ struct PlasmaGetReplyBuilder {
         : 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);
@@ -1799,9 +1742,7 @@ flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(flatbuffers::FlatBuffer
 
 struct PlasmaReleaseRequestT : public flatbuffers::NativeTable {
   typedef PlasmaReleaseRequest TableType;
-  std::string object_id;
-  PlasmaReleaseRequestT() {
-  }
+  std::string object_id{};
 };
 
 struct PlasmaReleaseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1835,7 +1776,6 @@ struct PlasmaReleaseRequestBuilder {
         : 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);
@@ -1864,11 +1804,8 @@ flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(flatbuffers
 
 struct PlasmaReleaseReplyT : public flatbuffers::NativeTable {
   typedef PlasmaReleaseReply TableType;
-  std::string object_id;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaReleaseReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  std::string object_id{};
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaReleaseReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1910,7 +1847,6 @@ struct PlasmaReleaseReplyBuilder {
         : 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);
@@ -1943,11 +1879,8 @@ flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(flatbuffers::Fl
 
 struct PlasmaDeleteRequestT : public flatbuffers::NativeTable {
   typedef PlasmaDeleteRequest TableType;
-  int32_t count;
-  std::vector<std::string> object_ids;
-  PlasmaDeleteRequestT()
-      : count(0) {
-  }
+  int32_t count = 0;
+  std::vector<std::string> object_ids{};
 };
 
 struct PlasmaDeleteRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1990,7 +1923,6 @@ struct PlasmaDeleteRequestBuilder {
         : 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);
@@ -2023,12 +1955,9 @@ flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(flatbuffers::
 
 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) {
-  }
+  int32_t count = 0;
+  std::vector<std::string> object_ids{};
+  std::vector<plasma::flatbuf::PlasmaError> errors{};
 };
 
 struct PlasmaDeleteReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2080,7 +2009,6 @@ struct PlasmaDeleteReplyBuilder {
         : 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);
@@ -2118,9 +2046,7 @@ flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(flatbuffers::Flat
 
 struct PlasmaContainsRequestT : public flatbuffers::NativeTable {
   typedef PlasmaContainsRequest TableType;
-  std::string object_id;
-  PlasmaContainsRequestT() {
-  }
+  std::string object_id{};
 };
 
 struct PlasmaContainsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2154,7 +2080,6 @@ struct PlasmaContainsRequestBuilder {
         : 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);
@@ -2183,11 +2108,8 @@ flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(flatbuffe
 
 struct PlasmaContainsReplyT : public flatbuffers::NativeTable {
   typedef PlasmaContainsReply TableType;
-  std::string object_id;
-  int32_t has_object;
-  PlasmaContainsReplyT()
-      : has_object(0) {
-  }
+  std::string object_id{};
+  int32_t has_object = 0;
 };
 
 struct PlasmaContainsReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2229,7 +2151,6 @@ struct PlasmaContainsReplyBuilder {
         : 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);
@@ -2262,8 +2183,6 @@ flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(flatbuffers::
 
 struct PlasmaListRequestT : public flatbuffers::NativeTable {
   typedef PlasmaListRequest TableType;
-  PlasmaListRequestT() {
-  }
 };
 
 struct PlasmaListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2286,7 +2205,6 @@ struct PlasmaListRequestBuilder {
         : 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);
@@ -2304,9 +2222,7 @@ flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(flatbuffers::Flat
 
 struct PlasmaListReplyT : public flatbuffers::NativeTable {
   typedef PlasmaListReply TableType;
-  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> objects;
-  PlasmaListReplyT() {
-  }
+  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> objects{};
 };
 
 struct PlasmaListReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2341,7 +2257,6 @@ struct PlasmaListReplyBuilder {
         : 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);
@@ -2370,8 +2285,6 @@ flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(flatbuffers::FlatBuff
 
 struct PlasmaConnectRequestT : public flatbuffers::NativeTable {
   typedef PlasmaConnectRequest TableType;
-  PlasmaConnectRequestT() {
-  }
 };
 
 struct PlasmaConnectRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2394,7 +2307,6 @@ struct PlasmaConnectRequestBuilder {
         : 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);
@@ -2412,10 +2324,7 @@ flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(flatbuffers
 
 struct PlasmaConnectReplyT : public flatbuffers::NativeTable {
   typedef PlasmaConnectReply TableType;
-  int64_t memory_capacity;
-  PlasmaConnectReplyT()
-      : memory_capacity(0) {
-  }
+  int64_t memory_capacity = 0;
 };
 
 struct PlasmaConnectReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2448,7 +2357,6 @@ struct PlasmaConnectReplyBuilder {
         : 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);
@@ -2468,10 +2376,7 @@ flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(flatbuffers::Fl
 
 struct PlasmaEvictRequestT : public flatbuffers::NativeTable {
   typedef PlasmaEvictRequest TableType;
-  uint64_t num_bytes;
-  PlasmaEvictRequestT()
-      : num_bytes(0) {
-  }
+  uint64_t num_bytes = 0;
 };
 
 struct PlasmaEvictRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2504,7 +2409,6 @@ struct PlasmaEvictRequestBuilder {
         : 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);
@@ -2524,10 +2428,7 @@ flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(flatbuffers::Fl
 
 struct PlasmaEvictReplyT : public flatbuffers::NativeTable {
   typedef PlasmaEvictReply TableType;
-  uint64_t num_bytes;
-  PlasmaEvictReplyT()
-      : num_bytes(0) {
-  }
+  uint64_t num_bytes = 0;
 };
 
 struct PlasmaEvictReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2560,7 +2461,6 @@ struct PlasmaEvictReplyBuilder {
         : 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);
@@ -2580,8 +2480,6 @@ flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(flatbuffers::FlatBu
 
 struct PlasmaSubscribeRequestT : public flatbuffers::NativeTable {
   typedef PlasmaSubscribeRequest TableType;
-  PlasmaSubscribeRequestT() {
-  }
 };
 
 struct PlasmaSubscribeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2604,7 +2502,6 @@ struct PlasmaSubscribeRequestBuilder {
         : 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);
@@ -2622,9 +2519,7 @@ flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(flatbuf
 
 struct PlasmaNotificationT : public flatbuffers::NativeTable {
   typedef PlasmaNotification TableType;
-  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> object_info;
-  PlasmaNotificationT() {
-  }
+  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> object_info{};
 };
 
 struct PlasmaNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2659,7 +2554,6 @@ struct PlasmaNotificationBuilder {
         : 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);
@@ -2688,12 +2582,9 @@ flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(flatbuffers::Fl
 
 struct PlasmaDataRequestT : public flatbuffers::NativeTable {
   typedef PlasmaDataRequest TableType;
-  std::string object_id;
-  std::string address;
-  int32_t port;
-  PlasmaDataRequestT()
-      : port(0) {
-  }
+  std::string object_id{};
+  std::string address{};
+  int32_t port = 0;
 };
 
 struct PlasmaDataRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2744,7 +2635,6 @@ struct PlasmaDataRequestBuilder {
         : 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);
@@ -2782,13 +2672,9 @@ flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(flatbuffers::Flat
 
 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) {
-  }
+  std::string object_id{};
+  uint64_t object_size = 0;
+  uint64_t metadata_size = 0;
 };
 
 struct PlasmaDataReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2838,7 +2724,6 @@ struct PlasmaDataReplyBuilder {
         : 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);
@@ -2875,9 +2760,7 @@ flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(flatbuffers::FlatBuff
 
 struct PlasmaRefreshLRURequestT : public flatbuffers::NativeTable {
   typedef PlasmaRefreshLRURequest TableType;
-  std::vector<std::string> object_ids;
-  PlasmaRefreshLRURequestT() {
-  }
+  std::vector<std::string> object_ids{};
 };
 
 struct PlasmaRefreshLRURequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2912,7 +2795,6 @@ struct PlasmaRefreshLRURequestBuilder {
         : 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);
@@ -2941,8 +2823,6 @@ flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequest(flatb
 
 struct PlasmaRefreshLRUReplyT : public flatbuffers::NativeTable {
   typedef PlasmaRefreshLRUReply TableType;
-  PlasmaRefreshLRUReplyT() {
-  }
 };
 
 struct PlasmaRefreshLRUReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2965,7 +2845,6 @@ struct PlasmaRefreshLRUReplyBuilder {
         : 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);
@@ -2982,7 +2861,7 @@ inline flatbuffers::Offset<PlasmaRefreshLRUReply> CreatePlasmaRefreshLRUReply(
 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());
+  auto _o = std::unique_ptr<PlasmaSetOptionsRequestT>(new PlasmaSetOptionsRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3011,7 +2890,7 @@ inline flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsReques
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaSetOptionsReplyT>(new PlasmaSetOptionsReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3037,7 +2916,7 @@ inline flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(fl
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaGetDebugStringRequestT>(new PlasmaGetDebugStringRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3060,7 +2939,7 @@ inline flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStri
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaGetDebugStringReplyT>(new PlasmaGetDebugStringReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3086,7 +2965,7 @@ inline flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugString
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaCreateRequestT>(new PlasmaCreateRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3124,7 +3003,7 @@ inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(flatbu
 }
 
 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());
+  auto _o = std::unique_ptr<CudaHandleT>(new CudaHandleT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3132,7 +3011,7 @@ inline CudaHandleT *CudaHandle::UnPack(const flatbuffers::resolver_function_t *_
 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); } } }
+  { auto _e = handle(); if (_e) { _o->handle.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->handle.begin()); } }
 }
 
 inline flatbuffers::Offset<CudaHandle> CudaHandle::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CudaHandleT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3150,7 +3029,7 @@ inline flatbuffers::Offset<CudaHandle> CreateCudaHandle(flatbuffers::FlatBufferB
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaCreateReplyT>(new PlasmaCreateReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3191,7 +3070,7 @@ inline flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(flatbuffer
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaCreateAndSealRequestT>(new PlasmaCreateAndSealRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3229,7 +3108,7 @@ inline flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSeal
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaCreateAndSealReplyT>(new PlasmaCreateAndSealReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3255,7 +3134,7 @@ inline flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealRe
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaCreateAndSealBatchRequestT>(new PlasmaCreateAndSealBatchRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3293,7 +3172,7 @@ inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAn
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaCreateAndSealBatchReplyT>(new PlasmaCreateAndSealBatchReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3319,7 +3198,7 @@ inline flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndS
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaAbortRequestT>(new PlasmaAbortRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3345,7 +3224,7 @@ inline flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(flatbuff
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaAbortReplyT>(new PlasmaAbortReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3371,7 +3250,7 @@ inline flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(flatbuffers:
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaSealRequestT>(new PlasmaSealRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3400,7 +3279,7 @@ inline flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(flatbuffer
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaSealReplyT>(new PlasmaSealReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3429,7 +3308,7 @@ inline flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(flatbuffers::F
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaGetRequestT>(new PlasmaGetRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3458,7 +3337,7 @@ inline flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(flatbuffers:
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaGetReplyT>(new PlasmaGetReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3496,7 +3375,7 @@ inline flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(flatbuffers::Fla
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaReleaseRequestT>(new PlasmaReleaseRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3522,7 +3401,7 @@ inline flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(flat
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaReleaseReplyT>(new PlasmaReleaseReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3551,7 +3430,7 @@ inline flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(flatbuff
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaDeleteRequestT>(new PlasmaDeleteRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3580,7 +3459,7 @@ inline flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(flatbu
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaDeleteReplyT>(new PlasmaDeleteReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3612,7 +3491,7 @@ inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(flatbuffer
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaContainsRequestT>(new PlasmaContainsRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3638,7 +3517,7 @@ inline flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(fl
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaContainsReplyT>(new PlasmaContainsReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3667,7 +3546,7 @@ inline flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(flatbu
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaListRequestT>(new PlasmaListRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3690,7 +3569,7 @@ inline flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(flatbuffer
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaListReplyT>(new PlasmaListReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3716,7 +3595,7 @@ inline flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(flatbuffers::F
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaConnectRequestT>(new PlasmaConnectRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3739,7 +3618,7 @@ inline flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(flat
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaConnectReplyT>(new PlasmaConnectReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3765,7 +3644,7 @@ inline flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(flatbuff
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaEvictRequestT>(new PlasmaEvictRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3791,7 +3670,7 @@ inline flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(flatbuff
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaEvictReplyT>(new PlasmaEvictReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3817,7 +3696,7 @@ inline flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(flatbuffers:
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaSubscribeRequestT>(new PlasmaSubscribeRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3840,7 +3719,7 @@ inline flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaNotificationT>(new PlasmaNotificationT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3866,7 +3745,7 @@ inline flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(flatbuff
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaDataRequestT>(new PlasmaDataRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3898,7 +3777,7 @@ inline flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(flatbuffer
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaDataReplyT>(new PlasmaDataReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3930,7 +3809,7 @@ inline flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(flatbuffers::F
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaRefreshLRURequestT>(new PlasmaRefreshLRURequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3956,7 +3835,7 @@ inline flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRUReques
 }
 
 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());
+  auto _o = std::unique_ptr<PlasmaRefreshLRUReplyT>(new PlasmaRefreshLRUReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
index 95573806723..de7898dcc2a 100644
--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
@@ -1,5 +1,5 @@
 #ifndef FLATBUFFERS_BASE_H_
-#define FLATBUFFERS_BASE_H_
+#  define FLATBUFFERS_BASE_H_
 
 // clang-format off
 
@@ -46,14 +46,17 @@
 #include <iterator>
 #include <memory>
 
+#if defined(__unix__) && !defined(FLATBUFFERS_LOCALE_INDEPENDENT)
+  #include <unistd.h>
+#endif
+
 #ifdef _STLPORT_VERSION
   #define FLATBUFFERS_CPP98_STL
 #endif
-#ifndef FLATBUFFERS_CPP98_STL
-  #include <functional>
-#endif
 
-#include "flatbuffers/stl_emulation.h"
+#ifdef __ANDROID__
+  #include <android/api-level.h>
+#endif
 
 #if defined(__ICCARM__)
 #include <intrinsics.h>
@@ -139,8 +142,8 @@
   #endif
 #endif // !defined(FLATBUFFERS_LITTLEENDIAN)
 
-#define FLATBUFFERS_VERSION_MAJOR 1
-#define FLATBUFFERS_VERSION_MINOR 12
+#define FLATBUFFERS_VERSION_MAJOR 2
+#define FLATBUFFERS_VERSION_MINOR 0
 #define FLATBUFFERS_VERSION_REVISION 0
 #define FLATBUFFERS_STRING_EXPAND(X) #X
 #define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
@@ -154,10 +157,12 @@ namespace flatbuffers {
     defined(__clang__)
   #define FLATBUFFERS_FINAL_CLASS final
   #define FLATBUFFERS_OVERRIDE override
+  #define FLATBUFFERS_EXPLICIT_CPP11 explicit
   #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE : flatbuffers::voffset_t
 #else
   #define FLATBUFFERS_FINAL_CLASS
   #define FLATBUFFERS_OVERRIDE
+  #define FLATBUFFERS_EXPLICIT_CPP11
   #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 #endif
 
@@ -165,13 +170,16 @@ namespace flatbuffers {
     (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \
     (defined(__cpp_constexpr) && __cpp_constexpr >= 200704)
   #define FLATBUFFERS_CONSTEXPR constexpr
+  #define FLATBUFFERS_CONSTEXPR_CPP11 constexpr
+  #define FLATBUFFERS_CONSTEXPR_DEFINED
 #else
   #define FLATBUFFERS_CONSTEXPR const
+  #define FLATBUFFERS_CONSTEXPR_CPP11
 #endif
 
 #if (defined(__cplusplus) && __cplusplus >= 201402L) || \
     (defined(__cpp_constexpr) && __cpp_constexpr >= 201304)
-  #define FLATBUFFERS_CONSTEXPR_CPP14 FLATBUFFERS_CONSTEXPR
+  #define FLATBUFFERS_CONSTEXPR_CPP14 FLATBUFFERS_CONSTEXPR_CPP11
 #else
   #define FLATBUFFERS_CONSTEXPR_CPP14
 #endif
@@ -189,9 +197,25 @@ namespace flatbuffers {
 #if (!defined(_MSC_VER) || _MSC_FULL_VER >= 180020827) && \
     (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 404)) || \
     defined(__clang__)
-  #define FLATBUFFERS_DELETE_FUNC(func) func = delete;
+  #define FLATBUFFERS_DELETE_FUNC(func) func = delete
 #else
-  #define FLATBUFFERS_DELETE_FUNC(func) private: func;
+  #define FLATBUFFERS_DELETE_FUNC(func) private: func
+#endif
+
+#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \
+    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || \
+    defined(__clang__)
+  #define FLATBUFFERS_DEFAULT_DECLARATION
+#endif
+
+// Check if we can use template aliases
+// Not possible if Microsoft Compiler before 2012
+// Possible is the language feature __cpp_alias_templates is defined well
+// Or possible if the C++ std is C+11 or newer
+#if (defined(_MSC_VER) && _MSC_VER > 1700 /* MSVC2012 */) \
+    || (defined(__cpp_alias_templates) && __cpp_alias_templates >= 200704) \
+    || (defined(__cplusplus) && __cplusplus >= 201103L)
+  #define FLATBUFFERS_TEMPLATES_ALIASES
 #endif
 
 #ifndef FLATBUFFERS_HAS_STRING_VIEW
@@ -223,6 +247,11 @@ namespace flatbuffers {
   #endif // __has_include
 #endif // !FLATBUFFERS_HAS_STRING_VIEW
 
+#ifndef FLATBUFFERS_GENERAL_HEAP_ALLOC_OK
+  // Allow heap allocations to be used
+  #define FLATBUFFERS_GENERAL_HEAP_ALLOC_OK 1
+#endif // !FLATBUFFERS_GENERAL_HEAP_ALLOC_OK
+
 #ifndef FLATBUFFERS_HAS_NEW_STRTOD
   // Modern (C++11) strtod and strtof functions are available for use.
   // 1) nan/inf strings as argument of strtod;
@@ -236,10 +265,8 @@ namespace flatbuffers {
 
 #ifndef FLATBUFFERS_LOCALE_INDEPENDENT
   // Enable locale independent functions {strtof_l, strtod_l,strtoll_l, strtoull_l}.
-  // They are part of the POSIX-2008 but not part of the C/C++ standard.
-  // GCC/Clang have definition (_XOPEN_SOURCE>=700) if POSIX-2008.
   #if ((defined(_MSC_VER) && _MSC_VER >= 1800)            || \
-       (defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE>=700)))
+       (defined(_XOPEN_VERSION) && (_XOPEN_VERSION>=700)) && (!defined(__ANDROID_API__) || (defined(__ANDROID_API__) && (__ANDROID_API__>=21))))
     #define FLATBUFFERS_LOCALE_INDEPENDENT 1
   #else
     #define FLATBUFFERS_LOCALE_INDEPENDENT 0
@@ -308,7 +335,13 @@ typedef uintmax_t largest_scalar_t;
 // We support aligning the contents of buffers up to this size.
 #define FLATBUFFERS_MAX_ALIGNMENT 16
 
+inline bool VerifyAlignmentRequirements(size_t align, size_t min_align = 1) {
+  return (min_align <= align) && (align <= (FLATBUFFERS_MAX_ALIGNMENT)) &&
+         (align & (align - 1)) == 0;  // must be power of 2
+}
+
 #if defined(_MSC_VER)
+  #pragma warning(disable: 4351) // C4351: new behavior: elements of array ... will be default initialized
   #pragma warning(push)
   #pragma warning(disable: 4127) // C4127: conditional expression is constant
 #endif
@@ -374,6 +407,13 @@ T ReadScalar(const void *p) {
   return EndianScalar(*reinterpret_cast<const T *>(p));
 }
 
+// See https://github.com/google/flatbuffers/issues/5950
+
+#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstringop-overflow"
+#endif
+
 template<typename T>
 // UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
 __supress_ubsan__("alignment")
@@ -386,6 +426,10 @@ template<typename T> __supress_ubsan__("alignment") void WriteScalar(void *p, Of
   *reinterpret_cast<uoffset_t *>(p) = EndianScalar(t.o);
 }
 
+#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)
+  #pragma GCC diagnostic pop
+#endif
+
 // Computes how many bytes you'd have to pad to be able to write an
 // "scalar_size" scalar if the buffer had grown to "buf_size" (downwards in
 // memory).
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h
index c4dc5bcd03c..1306bb33bc7 100644
--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h
@@ -18,6 +18,11 @@
 #define FLATBUFFERS_H_
 
 #include "flatbuffers/base.h"
+#include "flatbuffers/stl_emulation.h"
+
+#ifndef FLATBUFFERS_CPP98_STL
+#  include <functional>
+#endif
 
 #if defined(FLATBUFFERS_NAN_DEFAULTS)
 #  include <cmath>
@@ -167,8 +172,12 @@ template<typename T, typename IT> struct VectorIterator {
     return (data_ - other.data_) / IndirectHelper<T>::element_stride;
   }
 
+  // Note: return type is incompatible with the standard
+  // `reference operator*()`.
   IT operator*() const { return IndirectHelper<T>::Read(data_, 0); }
 
+  // Note: return type is incompatible with the standard
+  // `pointer operator->()`.
   IT operator->() const { return IndirectHelper<T>::Read(data_, 0); }
 
   VectorIterator &operator++() {
@@ -222,12 +231,18 @@ struct VectorReverseIterator : public std::reverse_iterator<Iterator> {
   explicit VectorReverseIterator(Iterator iter)
       : std::reverse_iterator<Iterator>(iter) {}
 
+  // Note: return type is incompatible with the standard
+  // `reference operator*()`.
   typename Iterator::value_type operator*() const {
-    return *(std::reverse_iterator<Iterator>::current);
+    auto tmp = std::reverse_iterator<Iterator>::current;
+    return *--tmp;
   }
 
+  // Note: return type is incompatible with the standard
+  // `pointer operator->()`.
   typename Iterator::value_type operator->() const {
-    return *(std::reverse_iterator<Iterator>::current);
+    auto tmp = std::reverse_iterator<Iterator>::current;
+    return *--tmp;
   }
 };
 
@@ -252,6 +267,7 @@ template<typename T> class Vector {
 
   typedef typename IndirectHelper<T>::return_type return_type;
   typedef typename IndirectHelper<T>::mutable_return_type mutable_return_type;
+  typedef return_type value_type;
 
   return_type Get(uoffset_t i) const {
     FLATBUFFERS_ASSERT(i < size());
@@ -289,14 +305,14 @@ template<typename T> class Vector {
   iterator end() { return iterator(Data(), size()); }
   const_iterator end() const { return const_iterator(Data(), size()); }
 
-  reverse_iterator rbegin() { return reverse_iterator(end() - 1); }
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
   const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end() - 1);
+    return const_reverse_iterator(end());
   }
 
-  reverse_iterator rend() { return reverse_iterator(begin() - 1); }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
   const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin() - 1);
+    return const_reverse_iterator(begin());
   }
 
   const_iterator cbegin() const { return begin(); }
@@ -430,6 +446,7 @@ template<typename T, uint16_t length> class Array {
           IndirectHelperType;
 
  public:
+  typedef uint16_t size_type;
   typedef typename IndirectHelper<IndirectHelperType>::return_type return_type;
   typedef VectorIterator<T, return_type> const_iterator;
   typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
@@ -456,7 +473,9 @@ template<typename T, uint16_t length> class Array {
   const_reverse_iterator rbegin() const {
     return const_reverse_iterator(end());
   }
-  const_reverse_iterator rend() const { return const_reverse_iterator(end()); }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
 
   const_iterator cbegin() const { return begin(); }
   const_iterator cend() const { return end(); }
@@ -487,6 +506,22 @@ template<typename T, uint16_t length> class Array {
   const T *data() const { return reinterpret_cast<const T *>(Data()); }
   T *data() { return reinterpret_cast<T *>(Data()); }
 
+  // Copy data from a span with endian conversion.
+  // If this Array and the span overlap, the behavior is undefined.
+  void CopyFromSpan(flatbuffers::span<const T, length> src) {
+    const auto p1 = reinterpret_cast<const uint8_t *>(src.data());
+    const auto p2 = Data();
+    FLATBUFFERS_ASSERT(!(p1 >= p2 && p1 < (p2 + length)) &&
+                       !(p2 >= p1 && p2 < (p1 + length)));
+    (void)p1;
+    (void)p2;
+
+    CopyFromSpanImpl(
+        flatbuffers::integral_constant < bool,
+        !scalar_tag::value || sizeof(T) == 1 || FLATBUFFERS_LITTLEENDIAN > (),
+        src);
+  }
+
  protected:
   void MutateImpl(flatbuffers::integral_constant<bool, true>, uoffset_t i,
                   const T &val) {
@@ -499,6 +534,20 @@ template<typename T, uint16_t length> class Array {
     *(GetMutablePointer(i)) = val;
   }
 
+  void CopyFromSpanImpl(flatbuffers::integral_constant<bool, true>,
+                        flatbuffers::span<const T, length> src) {
+    // Use std::memcpy() instead of std::copy() to avoid preformance degradation
+    // due to aliasing if T is char or unsigned char.
+    // The size is known at compile time, so memcpy would be inlined.
+    std::memcpy(data(), src.data(), length * sizeof(T));
+  }
+
+  // Copy data from flatbuffers::span with endian conversion.
+  void CopyFromSpanImpl(flatbuffers::integral_constant<bool, false>,
+                        flatbuffers::span<const T, length> src) {
+    for (size_type k = 0; k < length; k++) { Mutate(k, src[k]); }
+  }
+
   // This class is only used to access pre-existing data. Don't ever
   // try to construct these manually.
   // 'constexpr' allows us to use 'size()' at compile time.
@@ -544,6 +593,30 @@ template<typename T, uint16_t length> class Array<Offset<T>, length> {
   uint8_t data_[1];
 };
 
+// Cast a raw T[length] to a raw flatbuffers::Array<T, length>
+// without endian conversion. Use with care.
+template<typename T, uint16_t length>
+Array<T, length> &CastToArray(T (&arr)[length]) {
+  return *reinterpret_cast<Array<T, length> *>(arr);
+}
+
+template<typename T, uint16_t length>
+const Array<T, length> &CastToArray(const T (&arr)[length]) {
+  return *reinterpret_cast<const Array<T, length> *>(arr);
+}
+
+template<typename E, typename T, uint16_t length>
+Array<E, length> &CastToArrayOfEnum(T (&arr)[length]) {
+  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
+  return *reinterpret_cast<Array<E, length> *>(arr);
+}
+
+template<typename E, typename T, uint16_t length>
+const Array<E, length> &CastToArrayOfEnum(const T (&arr)[length]) {
+  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
+  return *reinterpret_cast<const Array<E, length> *>(arr);
+}
+
 // Lexicographically compare two strings (possibly containing nulls), and
 // return true if the first is less than the second.
 static inline bool StringLessThan(const char *a_data, uoffset_t a_size,
@@ -581,6 +654,14 @@ static inline const char *GetCstring(const String *str) {
   return str ? str->c_str() : "";
 }
 
+#ifdef FLATBUFFERS_HAS_STRING_VIEW
+// Convenience function to get string_view from a String returning an empty
+// string_view on null pointer.
+static inline flatbuffers::string_view GetStringView(const String *str) {
+  return str ? str->string_view() : flatbuffers::string_view();
+}
+#endif  // FLATBUFFERS_HAS_STRING_VIEW
+
 // Allocator interface. This is flatbuffers-specific and meant only for
 // `vector_downward` usage.
 class Allocator {
@@ -753,9 +834,9 @@ class DetachedBuffer {
   #if !defined(FLATBUFFERS_CPP98_STL)
   // clang-format on
   // These may change access mode, leave these at end of public section
-  FLATBUFFERS_DELETE_FUNC(DetachedBuffer(const DetachedBuffer &other))
+  FLATBUFFERS_DELETE_FUNC(DetachedBuffer(const DetachedBuffer &other));
   FLATBUFFERS_DELETE_FUNC(
-      DetachedBuffer &operator=(const DetachedBuffer &other))
+      DetachedBuffer &operator=(const DetachedBuffer &other));
   // clang-format off
   #endif  // !defined(FLATBUFFERS_CPP98_STL)
   // clang-format on
@@ -920,7 +1001,7 @@ class vector_downward {
   Allocator *get_custom_allocator() { return allocator_; }
 
   uoffset_t size() const {
-    return static_cast<uoffset_t>(reserved_ - (cur_ - buf_));
+    return static_cast<uoffset_t>(reserved_ - static_cast<size_t>(cur_ - buf_));
   }
 
   uoffset_t scratch_size() const {
@@ -998,8 +1079,8 @@ class vector_downward {
 
  private:
   // You shouldn't really be copying instances of this class.
-  FLATBUFFERS_DELETE_FUNC(vector_downward(const vector_downward &))
-  FLATBUFFERS_DELETE_FUNC(vector_downward &operator=(const vector_downward &))
+  FLATBUFFERS_DELETE_FUNC(vector_downward(const vector_downward &));
+  FLATBUFFERS_DELETE_FUNC(vector_downward &operator=(const vector_downward &));
 
   Allocator *allocator_;
   bool own_allocator_;
@@ -1171,6 +1252,14 @@ class FlatBufferBuilder {
     return buf_.data();
   }
 
+  /// @brief Get the serialized buffer (after you call `Finish()`) as a span.
+  /// @return Returns a constructed flatbuffers::span that is a view over the
+  /// FlatBuffer data inside the buffer.
+  flatbuffers::span<uint8_t> GetBufferSpan() const {
+    Finished();
+    return flatbuffers::span<uint8_t>(buf_.data(), buf_.size());
+  }
+
   /// @brief Get a pointer to an unfinished buffer.
   /// @return Returns a `uint8_t` pointer to the unfinished buffer.
   uint8_t *GetCurrentBufferPointer() const { return buf_.data(); }
@@ -1211,7 +1300,7 @@ class FlatBufferBuilder {
   /// you call Finish()). You can use this information if you need to embed
   /// a FlatBuffer in some other buffer, such that you can later read it
   /// without first having to copy it into its own buffer.
-  size_t GetBufferMinAlignment() {
+  size_t GetBufferMinAlignment() const {
     Finished();
     return minalign_;
   }
@@ -1267,9 +1356,8 @@ class FlatBufferBuilder {
   // Write a single aligned scalar to the buffer
   template<typename T> uoffset_t PushElement(T element) {
     AssertScalarT<T>();
-    T litle_endian_element = EndianScalar(element);
     Align(sizeof(T));
-    buf_.push_small(litle_endian_element);
+    buf_.push_small(EndianScalar(element));
     return GetSize();
   }
 
@@ -1295,6 +1383,11 @@ class FlatBufferBuilder {
     TrackField(field, off);
   }
 
+  template<typename T> void AddElement(voffset_t field, T e) {
+    auto off = PushElement(e);
+    TrackField(field, off);
+  }
+
   template<typename T> void AddOffset(voffset_t field, Offset<T> off) {
     if (off.IsNull()) return;  // Don't store.
     AddElement(field, ReferTo(off.o), static_cast<uoffset_t>(0));
@@ -1507,11 +1600,13 @@ class FlatBufferBuilder {
 
   /// @brief Store a string in the buffer, which can contain any binary data.
   /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string.
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
   /// @param[in] str A const char pointer to the data to be stored as a string.
   /// @param[in] len The number of bytes that should be stored from `str`.
   /// @return Returns the offset in the buffer where the string starts.
   Offset<String> CreateSharedString(const char *str, size_t len) {
+    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
     if (!string_pool)
       string_pool = new StringOffsetMap(StringOffsetCompare(buf_));
     auto size_before_string = buf_.size();
@@ -1530,9 +1625,21 @@ class FlatBufferBuilder {
     return off;
   }
 
+#ifdef FLATBUFFERS_HAS_STRING_VIEW
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const std::string_view to store in the buffer.
+  /// @return Returns the offset in the buffer where the string starts
+  Offset<String> CreateSharedString(const flatbuffers::string_view str) {
+    return CreateSharedString(str.data(), str.size());
+  }
+#else
   /// @brief Store a string in the buffer, which null-terminated.
   /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string.
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
   /// @param[in] str A const char pointer to a C-string to add to the buffer.
   /// @return Returns the offset in the buffer where the string starts.
   Offset<String> CreateSharedString(const char *str) {
@@ -1541,16 +1648,19 @@ class FlatBufferBuilder {
 
   /// @brief Store a string in the buffer, which can contain any binary data.
   /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string.
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
   /// @param[in] str A const reference to a std::string to store in the buffer.
   /// @return Returns the offset in the buffer where the string starts.
   Offset<String> CreateSharedString(const std::string &str) {
     return CreateSharedString(str.c_str(), str.length());
   }
+#endif
 
   /// @brief Store a string in the buffer, which can contain any binary data.
   /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string.
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
   /// @param[in] str A const pointer to a `String` struct to add to the buffer.
   /// @return Returns the offset in the buffer where the string starts
   Offset<String> CreateSharedString(const String *str) {
@@ -1577,11 +1687,13 @@ class FlatBufferBuilder {
   // This is useful when storing a nested_flatbuffer in a vector of bytes,
   // or when storing SIMD floats, etc.
   void ForceVectorAlignment(size_t len, size_t elemsize, size_t alignment) {
+    FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
     PreAlign(len * elemsize, alignment);
   }
 
   // Similar to ForceVectorAlignment but for String fields.
   void ForceStringAlignment(size_t len, size_t alignment) {
+    FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
     PreAlign((len + 1) * sizeof(char), alignment);
   }
 
@@ -1599,6 +1711,7 @@ class FlatBufferBuilder {
     // causing the wrong overload to be selected, remove it.
     AssertScalarT<T>();
     StartVector(len, sizeof(T));
+    if (len == 0) { return Offset<Vector<T>>(EndVector(len)); }
     // clang-format off
     #if FLATBUFFERS_LITTLEENDIAN
       PushBytes(reinterpret_cast<const uint8_t *>(v), len * sizeof(T));
@@ -1654,15 +1767,18 @@ class FlatBufferBuilder {
   /// where the vector is stored.
   template<typename T> Offset<Vector<T>> CreateVector(size_t vector_size,
       const std::function<T (size_t i)> &f) {
+    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
     std::vector<T> elems(vector_size);
     for (size_t i = 0; i < vector_size; i++) elems[i] = f(i);
     return CreateVector(elems);
   }
-  #endif
+  #endif // FLATBUFFERS_CPP98_STL
   // clang-format on
 
   /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
-  /// This is a convenience function that takes care of iteration for you.
+  /// This is a convenience function that takes care of iteration for you. This
+  /// uses a vector stored on the heap to store the intermediate results of the
+  /// iteration.
   /// @tparam T The data type of the `std::vector` elements.
   /// @param f A function that takes the current iteration 0..vector_size-1,
   /// and the state parameter returning any type that you can construct a
@@ -1672,6 +1788,7 @@ class FlatBufferBuilder {
   /// where the vector is stored.
   template<typename T, typename F, typename S>
   Offset<Vector<T>> CreateVector(size_t vector_size, F f, S *state) {
+    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
     std::vector<T> elems(vector_size);
     for (size_t i = 0; i < vector_size; i++) elems[i] = f(i, state);
     return CreateVector(elems);
@@ -1685,9 +1802,35 @@ class FlatBufferBuilder {
   /// where the vector is stored.
   Offset<Vector<Offset<String>>> CreateVectorOfStrings(
       const std::vector<std::string> &v) {
-    std::vector<Offset<String>> offsets(v.size());
-    for (size_t i = 0; i < v.size(); i++) offsets[i] = CreateString(v[i]);
-    return CreateVector(offsets);
+    return CreateVectorOfStrings(v.cbegin(), v.cend());
+  }
+
+  /// @brief Serialize a collection of Strings into a FlatBuffer `vector`.
+  /// This is a convenience function for a common case.
+  /// @param begin The begining iterator of the collection
+  /// @param end The ending iterator of the collection
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<class It>
+  Offset<Vector<Offset<String>>> CreateVectorOfStrings(It begin, It end) {
+    auto size = std::distance(begin, end);
+    auto scratch_buffer_usage = size * sizeof(Offset<String>);
+    // If there is not enough space to store the offsets, there definitely won't
+    // be enough space to store all the strings. So ensuring space for the
+    // scratch region is OK, for it it fails, it would have failed later.
+    buf_.ensure_space(scratch_buffer_usage);
+    for (auto it = begin; it != end; ++it) {
+      buf_.scratch_push_small(CreateString(*it));
+    }
+    StartVector(size, sizeof(Offset<String>));
+    for (auto i = 1; i <= size; i++) {
+      // Note we re-evaluate the buf location each iteration to account for any
+      // underlying buffer resizing that may occur.
+      PushElement(*reinterpret_cast<Offset<String> *>(
+          buf_.scratch_end() - i * sizeof(Offset<String>)));
+    }
+    buf_.scratch_pop(scratch_buffer_usage);
+    return Offset<Vector<Offset<String>>>(EndVector(size));
   }
 
   /// @brief Serialize an array of structs into a FlatBuffer `vector`.
@@ -1704,6 +1847,25 @@ class FlatBufferBuilder {
     return Offset<Vector<const T *>>(EndVector(len));
   }
 
+  /// @brief Serialize an array of native structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @tparam S The data type of the native struct array elements.
+  /// @param[in] v A pointer to the array of type `S` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @param[in] pack_func Pointer to a function to convert the native struct
+  /// to the FlatBuffer struct.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename S>
+  Offset<Vector<const T *>> CreateVectorOfNativeStructs(
+      const S *v, size_t len, T((*const pack_func)(const S &))) {
+    FLATBUFFERS_ASSERT(pack_func);
+    auto structs = StartVectorOfStructs<T>(len);
+    for (size_t i = 0; i < len; i++) { structs[i] = pack_func(v[i]); }
+    return EndVectorOfStructs<T>(len);
+  }
+
   /// @brief Serialize an array of native structs into a FlatBuffer `vector`.
   /// @tparam T The data type of the struct array elements.
   /// @tparam S The data type of the native struct array elements.
@@ -1716,9 +1878,7 @@ class FlatBufferBuilder {
   Offset<Vector<const T *>> CreateVectorOfNativeStructs(const S *v,
                                                         size_t len) {
     extern T Pack(const S &);
-    std::vector<T> vv(len);
-    std::transform(v, v + len, vv.begin(), Pack);
-    return CreateVectorOfStructs<T>(data(vv), vv.size());
+    return CreateVectorOfNativeStructs(v, len, Pack);
   }
 
   // clang-format off
@@ -1775,6 +1935,22 @@ class FlatBufferBuilder {
     return CreateVectorOfStructs(data(v), v.size());
   }
 
+  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
+  /// `vector`.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @tparam S The data type of the `std::vector` native struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @param[in] pack_func Pointer to a function to convert the native struct
+  /// to the FlatBuffer struct.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename S>
+  Offset<Vector<const T *>> CreateVectorOfNativeStructs(
+      const std::vector<S> &v, T((*const pack_func)(const S &))) {
+    return CreateVectorOfNativeStructs<T, S>(data(v), v.size(), pack_func);
+  }
+
   /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
   /// `vector`.
   /// @tparam T The data type of the `std::vector` struct elements.
@@ -1795,8 +1971,8 @@ class FlatBufferBuilder {
       return a.KeyCompareLessThan(&b);
     }
 
-   private:
-    StructKeyComparator &operator=(const StructKeyComparator &);
+    FLATBUFFERS_DELETE_FUNC(
+        StructKeyComparator &operator=(const StructKeyComparator &));
   };
   /// @endcond
 
@@ -1853,10 +2029,10 @@ class FlatBufferBuilder {
   Offset<Vector<const T *>> CreateVectorOfSortedNativeStructs(S *v,
                                                               size_t len) {
     extern T Pack(const S &);
-    typedef T (*Pack_t)(const S &);
-    std::vector<T> vv(len);
-    std::transform(v, v + len, vv.begin(), static_cast<Pack_t &>(Pack));
-    return CreateVectorOfSortedStructs<T>(vv, len);
+    auto structs = StartVectorOfStructs<T>(len);
+    for (size_t i = 0; i < len; i++) { structs[i] = Pack(v[i]); }
+    std::sort(structs, structs + len, StructKeyComparator<T>());
+    return EndVectorOfStructs<T>(len);
   }
 
   /// @cond FLATBUFFERS_INTERNAL
@@ -1871,10 +2047,8 @@ class FlatBufferBuilder {
     vector_downward &buf_;
 
    private:
-    TableKeyComparator &operator=(const TableKeyComparator &other) {
-      buf_ = other.buf_;
-      return *this;
-    }
+    FLATBUFFERS_DELETE_FUNC(
+        TableKeyComparator &operator=(const TableKeyComparator &other));
   };
   /// @endcond
 
@@ -2269,8 +2443,8 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
 
   template<typename T>
   bool VerifyBufferFromStart(const char *identifier, size_t start) {
-    if (identifier && (size_ < 2 * sizeof(flatbuffers::uoffset_t) ||
-                       !BufferHasIdentifier(buf_ + start, identifier))) {
+    if (identifier && !Check((size_ >= 2 * sizeof(flatbuffers::uoffset_t) &&
+                              BufferHasIdentifier(buf_ + start, identifier)))) {
       return false;
     }
 
@@ -2452,12 +2626,26 @@ class Table {
     return field_offset ? reinterpret_cast<P>(p) : nullptr;
   }
 
+  template<typename Raw, typename Face>
+  flatbuffers::Optional<Face> GetOptional(voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    auto p = data_ + field_offset;
+    return field_offset ? Optional<Face>(static_cast<Face>(ReadScalar<Raw>(p)))
+                        : Optional<Face>();
+  }
+
   template<typename T> bool SetField(voffset_t field, T val, T def) {
     auto field_offset = GetOptionalFieldOffset(field);
     if (!field_offset) return IsTheSameAs(val, def);
     WriteScalar(data_ + field_offset, val);
     return true;
   }
+  template<typename T> bool SetField(voffset_t field, T val) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    if (!field_offset) return false;
+    WriteScalar(data_ + field_offset, val);
+    return true;
+  }
 
   bool SetPointer(voffset_t field, const uint8_t *val) {
     auto field_offset = GetOptionalFieldOffset(field);
@@ -2525,6 +2713,17 @@ class Table {
   uint8_t data_[1];
 };
 
+// This specialization allows avoiding warnings like:
+// MSVC C4800: type: forcing value to bool 'true' or 'false'.
+template<>
+inline flatbuffers::Optional<bool> Table::GetOptional<uint8_t, bool>(
+    voffset_t field) const {
+  auto field_offset = GetOptionalFieldOffset(field);
+  auto p = data_ + field_offset;
+  return field_offset ? Optional<bool>(ReadScalar<uint8_t>(p) != 0)
+                      : Optional<bool>();
+}
+
 template<typename T>
 void FlatBufferBuilder::Required(Offset<T> table, voffset_t field) {
   auto table_ptr = reinterpret_cast<const Table *>(buf_.data_at(table.o));
@@ -2702,10 +2901,16 @@ inline const char * const *ElementaryTypeNames() {
 // clang-format on
 
 // Basic type info cost just 16bits per field!
+// We're explicitly defining the signedness since the signedness of integer
+// bitfields is otherwise implementation-defined and causes warnings on older
+// GCC compilers.
 struct TypeCode {
-  uint16_t base_type : 4;  // ElementaryType
-  uint16_t is_vector : 1;
-  int16_t sequence_ref : 11;  // Index into type_refs below, or -1 for none.
+  // ElementaryType
+  unsigned short base_type : 4;
+  // Either vector (in table) or array (in struct)
+  unsigned short is_repeating : 1;
+  // Index into type_refs below, or -1 for none.
+  signed short sequence_ref : 11;
 };
 
 static_assert(sizeof(TypeCode) == 2, "TypeCode");
@@ -2720,6 +2925,7 @@ struct TypeTable {
   size_t num_elems;  // of type_codes, values, names (but not type_refs).
   const TypeCode *type_codes;     // num_elems count
   const TypeFunction *type_refs;  // less than num_elems entries (see TypeCode).
+  const int16_t *array_sizes;     // less than num_elems entries (see TypeCode).
   const int64_t *values;  // Only set for non-consecutive enum/union or structs.
   const char *const *names;  // Only set if compiled with --reflect-names.
 };
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h
index 8bae61bfd6a..70e5dc944e3 100644
--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h
@@ -18,6 +18,7 @@
 #define FLATBUFFERS_STL_EMULATION_H_
 
 // clang-format off
+#include "flatbuffers/base.h"
 
 #include <string>
 #include <type_traits>
@@ -33,15 +34,34 @@
   #include <cctype>
 #endif  // defined(FLATBUFFERS_CPP98_STL)
 
-// Check if we can use template aliases
-// Not possible if Microsoft Compiler before 2012
-// Possible is the language feature __cpp_alias_templates is defined well
-// Or possible if the C++ std is C+11 or newer
-#if (defined(_MSC_VER) && _MSC_VER > 1700 /* MSVC2012 */) \
-    || (defined(__cpp_alias_templates) && __cpp_alias_templates >= 200704) \
-    || (defined(__cplusplus) && __cplusplus >= 201103L)
-  #define FLATBUFFERS_TEMPLATES_ALIASES
-#endif
+// Detect C++17 compatible compiler.
+// __cplusplus >= 201703L - a compiler has support of 'static inline' variables.
+#if defined(FLATBUFFERS_USE_STD_OPTIONAL) \
+    || (defined(__cplusplus) && __cplusplus >= 201703L) \
+    || (defined(_MSVC_LANG) &&  (_MSVC_LANG >= 201703L))
+  #include <optional>
+  #ifndef FLATBUFFERS_USE_STD_OPTIONAL
+    #define FLATBUFFERS_USE_STD_OPTIONAL
+  #endif
+#endif // defined(FLATBUFFERS_USE_STD_OPTIONAL) ...
+
+// The __cpp_lib_span is the predefined feature macro.
+#if defined(FLATBUFFERS_USE_STD_SPAN)
+    #include <span>
+#elif defined(__cpp_lib_span) && defined(__has_include)
+  #if __has_include(<span>)
+    #include <span>
+    #define FLATBUFFERS_USE_STD_SPAN
+  #endif
+#else
+  // Disable non-trivial ctors if FLATBUFFERS_SPAN_MINIMAL defined.
+  #if !defined(FLATBUFFERS_TEMPLATES_ALIASES) || defined(FLATBUFFERS_CPP98_STL)
+    #define FLATBUFFERS_SPAN_MINIMAL
+  #else
+    // Enable implicit construction of a span<T,N> from a std::array<T,N>.
+    #include <array>
+  #endif
+#endif // defined(FLATBUFFERS_USE_STD_SPAN)
 
 // This header provides backwards compatibility for C++98 STLs like stlport.
 namespace flatbuffers {
@@ -144,6 +164,8 @@ inline void vector_emplace_back(std::vector<T> *vector, V &&data) {
     using conditional = std::conditional<B, T, F>;
     template<class T, T v>
     using integral_constant = std::integral_constant<T, v>;
+    template <bool B>
+    using bool_constant = integral_constant<bool, B>;
   #else
     // Map C++ TR1 templates defined by stlport.
     template <typename T> using is_scalar = std::tr1::is_scalar<T>;
@@ -167,6 +189,8 @@ inline void vector_emplace_back(std::vector<T> *vector, V &&data) {
     using conditional = std::tr1::conditional<B, T, F>;
     template<class T, T v>
     using integral_constant = std::tr1::integral_constant<T, v>;
+    template <bool B>
+    using bool_constant = integral_constant<bool, B>;
   #endif  // !FLATBUFFERS_CPP98_STL
 #else
   // MSVC 2010 doesn't support C++11 aliases.
@@ -181,6 +205,8 @@ inline void vector_emplace_back(std::vector<T> *vector, V &&data) {
   struct conditional : public std::conditional<B, T, F> {};
   template<class T, T v>
   struct integral_constant : public std::integral_constant<T, v> {};
+  template <bool B>
+  struct bool_constant : public integral_constant<bool, B> {};
 #endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
 
 #ifndef FLATBUFFERS_CPP98_STL
@@ -190,7 +216,7 @@ inline void vector_emplace_back(std::vector<T> *vector, V &&data) {
     // MSVC 2010 doesn't support C++11 aliases.
     // We're manually "aliasing" the class here as we want to bring unique_ptr
     // into the flatbuffers namespace.  We have unique_ptr in the flatbuffers
-    // namespace we have a completely independent implemenation (see below)
+    // namespace we have a completely independent implementation (see below)
     // for C++98 STL implementations.
     template <class T> class unique_ptr : public std::unique_ptr<T> {
      public:
@@ -302,6 +328,346 @@ inline void vector_emplace_back(std::vector<T> *vector, V &&data) {
 
 #endif  // !FLATBUFFERS_CPP98_STL
 
+#ifdef FLATBUFFERS_USE_STD_OPTIONAL
+template<class T>
+using Optional = std::optional<T>;
+using nullopt_t = std::nullopt_t;
+inline constexpr nullopt_t nullopt = std::nullopt;
+
+#else
+// Limited implementation of Optional<T> type for a scalar T.
+// This implementation limited by trivial types compatible with
+// std::is_arithmetic<T> or std::is_enum<T> type traits.
+
+// A tag to indicate an empty flatbuffers::optional<T>.
+struct nullopt_t {
+  explicit FLATBUFFERS_CONSTEXPR_CPP11 nullopt_t(int) {}
+};
+
+#if defined(FLATBUFFERS_CONSTEXPR_DEFINED)
+  namespace internal {
+    template <class> struct nullopt_holder {
+      static constexpr nullopt_t instance_ = nullopt_t(0);
+    };
+    template<class Dummy>
+    constexpr nullopt_t nullopt_holder<Dummy>::instance_;
+  }
+  static constexpr const nullopt_t &nullopt = internal::nullopt_holder<void>::instance_;
+
+#else
+  namespace internal {
+    template <class> struct nullopt_holder {
+      static const nullopt_t instance_;
+    };
+    template<class Dummy>
+    const nullopt_t nullopt_holder<Dummy>::instance_  = nullopt_t(0);
+  }
+  static const nullopt_t &nullopt = internal::nullopt_holder<void>::instance_;
+
+#endif
+
+template<class T>
+class Optional FLATBUFFERS_FINAL_CLASS {
+  // Non-scalar 'T' would extremely complicated Optional<T>.
+  // Use is_scalar<T> checking because flatbuffers flatbuffers::is_arithmetic<T>
+  // isn't implemented.
+  static_assert(flatbuffers::is_scalar<T>::value, "unexpected type T");
+
+ public:
+  ~Optional() {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional() FLATBUFFERS_NOEXCEPT
+    : value_(), has_value_(false) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional(nullopt_t) FLATBUFFERS_NOEXCEPT
+    : value_(), has_value_(false) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional(T val) FLATBUFFERS_NOEXCEPT
+    : value_(val), has_value_(true) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional(const Optional &other) FLATBUFFERS_NOEXCEPT
+    : value_(other.value_), has_value_(other.has_value_) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(const Optional &other) FLATBUFFERS_NOEXCEPT {
+    value_ = other.value_;
+    has_value_ = other.has_value_;
+    return *this;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(nullopt_t) FLATBUFFERS_NOEXCEPT {
+    value_ = T();
+    has_value_ = false;
+    return *this;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(T val) FLATBUFFERS_NOEXCEPT {
+    value_ = val;
+    has_value_ = true;
+    return *this;
+  }
+
+  void reset() FLATBUFFERS_NOEXCEPT {
+    *this = nullopt;
+  }
+
+  void swap(Optional &other) FLATBUFFERS_NOEXCEPT {
+    std::swap(value_, other.value_);
+    std::swap(has_value_, other.has_value_);
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 FLATBUFFERS_EXPLICIT_CPP11 operator bool() const FLATBUFFERS_NOEXCEPT {
+    return has_value_;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 bool has_value() const FLATBUFFERS_NOEXCEPT {
+    return has_value_;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 const T& operator*() const FLATBUFFERS_NOEXCEPT {
+    return value_;
+  }
+
+  const T& value() const {
+    FLATBUFFERS_ASSERT(has_value());
+    return value_;
+  }
+
+  T value_or(T default_value) const FLATBUFFERS_NOEXCEPT {
+    return has_value() ? value_ : default_value;
+  }
+
+ private:
+  T value_;
+  bool has_value_;
+};
+
+template<class T>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& opt, nullopt_t) FLATBUFFERS_NOEXCEPT {
+  return !opt;
+}
+template<class T>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(nullopt_t, const Optional<T>& opt) FLATBUFFERS_NOEXCEPT {
+  return !opt;
+}
+
+template<class T, class U>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& lhs, const U& rhs) FLATBUFFERS_NOEXCEPT {
+  return static_cast<bool>(lhs) && (*lhs == rhs);
+}
+
+template<class T, class U>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const T& lhs, const Optional<U>& rhs) FLATBUFFERS_NOEXCEPT {
+  return static_cast<bool>(rhs) && (lhs == *rhs);
+}
+
+template<class T, class U>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& lhs, const Optional<U>& rhs) FLATBUFFERS_NOEXCEPT {
+  return static_cast<bool>(lhs) != static_cast<bool>(rhs)
+              ? false
+              : !static_cast<bool>(lhs) ? false : (*lhs == *rhs);
+}
+#endif // FLATBUFFERS_USE_STD_OPTIONAL
+
+
+// Very limited and naive partial implementation of C++20 std::span<T,Extent>.
+#if defined(FLATBUFFERS_USE_STD_SPAN)
+  inline constexpr std::size_t dynamic_extent = std::dynamic_extent;
+  template<class T, std::size_t Extent = std::dynamic_extent>
+  using span = std::span<T, Extent>;
+
+#else // !defined(FLATBUFFERS_USE_STD_SPAN)
+FLATBUFFERS_CONSTEXPR std::size_t dynamic_extent = static_cast<std::size_t>(-1);
+
+// Exclude this code if MSVC2010 or non-STL Android is active.
+// The non-STL Android doesn't have `std::is_convertible` required for SFINAE.
+#if !defined(FLATBUFFERS_SPAN_MINIMAL)
+namespace internal {
+  // This is SFINAE helper class for checking of a common condition:
+  // > This overload only participates in overload resolution
+  // > Check whether a pointer to an array of U can be converted
+  // > to a pointer to an array of E.
+  // This helper is used for checking of 'U -> const U'.
+  template<class E, std::size_t Extent, class U, std::size_t N>
+  struct is_span_convertable {
+    using type =
+      typename std::conditional<std::is_convertible<U (*)[], E (*)[]>::value
+                                && (Extent == dynamic_extent || N == Extent),
+                                int, void>::type;
+  };
+
+}  // namespace internal
+#endif  // !defined(FLATBUFFERS_SPAN_MINIMAL)
+
+// T - element type; must be a complete type that is not an abstract
+// class type.
+// Extent - the number of elements in the sequence, or dynamic.
+template<class T, std::size_t Extent = dynamic_extent>
+class span FLATBUFFERS_FINAL_CLASS {
+ public:
+  typedef T element_type;
+  typedef T& reference;
+  typedef const T& const_reference;
+  typedef T* pointer;
+  typedef const T* const_pointer;
+  typedef std::size_t size_type;
+
+  static FLATBUFFERS_CONSTEXPR size_type extent = Extent;
+
+  // Returns the number of elements in the span.
+  FLATBUFFERS_CONSTEXPR_CPP11 size_type size() const FLATBUFFERS_NOEXCEPT {
+    return count_;
+  }
+
+  // Returns the size of the sequence in bytes.
+  FLATBUFFERS_CONSTEXPR_CPP11
+  size_type size_bytes() const FLATBUFFERS_NOEXCEPT {
+    return size() * sizeof(element_type);
+  }
+
+  // Checks if the span is empty.
+  FLATBUFFERS_CONSTEXPR_CPP11 bool empty() const FLATBUFFERS_NOEXCEPT {
+    return size() == 0;
+  }
+
+  // Returns a pointer to the beginning of the sequence.
+  FLATBUFFERS_CONSTEXPR_CPP11 pointer data() const FLATBUFFERS_NOEXCEPT {
+    return data_;
+  }
+
+  // Returns a reference to the idx-th element of the sequence.
+  // The behavior is undefined if the idx is greater than or equal to size().
+  FLATBUFFERS_CONSTEXPR_CPP11 reference operator[](size_type idx) const {
+    return data()[idx];
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 span(const span &other) FLATBUFFERS_NOEXCEPT
+      : data_(other.data_), count_(other.count_) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP14 span &operator=(const span &other)
+      FLATBUFFERS_NOEXCEPT {
+    data_ = other.data_;
+    count_ = other.count_;
+  }
+
+  // Limited implementation of
+  // `template <class It> constexpr std::span(It first, size_type count);`.
+  //
+  // Constructs a span that is a view over the range [first, first + count);
+  // the resulting span has: data() == first and size() == count.
+  // The behavior is undefined if [first, first + count) is not a valid range,
+  // or if (extent != flatbuffers::dynamic_extent && count != extent).
+  FLATBUFFERS_CONSTEXPR_CPP11
+  explicit span(pointer first, size_type count) FLATBUFFERS_NOEXCEPT
+    : data_ (Extent == dynamic_extent ? first : (Extent == count ? first : nullptr)),
+      count_(Extent == dynamic_extent ? count : (Extent == count ? Extent : 0)) {
+      // Make span empty if the count argument is incompatible with span<T,N>.
+  }
+
+  // Exclude this code if MSVC2010 is active. The MSVC2010 isn't C++11
+  // compliant, it doesn't support default template arguments for functions.
+  #if defined(FLATBUFFERS_SPAN_MINIMAL)
+  FLATBUFFERS_CONSTEXPR_CPP11 span() FLATBUFFERS_NOEXCEPT : data_(nullptr),
+                                                            count_(0) {
+    static_assert(extent == 0 || extent == dynamic_extent, "invalid span");
+  }
+
+  #else
+  // Constructs an empty span whose data() == nullptr and size() == 0.
+  // This overload only participates in overload resolution if
+  // extent == 0 || extent == flatbuffers::dynamic_extent.
+  // A dummy template argument N is need dependency for SFINAE.
+  template<std::size_t N = 0,
+    typename internal::is_span_convertable<element_type, Extent, element_type, (N - N)>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span() FLATBUFFERS_NOEXCEPT : data_(nullptr),
+                                                            count_(0) {
+    static_assert(extent == 0 || extent == dynamic_extent, "invalid span");
+  }
+
+  // Constructs a span that is a view over the array arr; the resulting span
+  // has size() == N and data() == std::data(arr). These overloads only
+  // participate in overload resolution if
+  // extent == std::dynamic_extent || N == extent is true and
+  // std::remove_pointer_t<decltype(std::data(arr))>(*)[]
+  // is convertible to element_type (*)[].
+  template<std::size_t N,
+    typename internal::is_span_convertable<element_type, Extent, element_type, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(element_type (&arr)[N]) FLATBUFFERS_NOEXCEPT
+      : data_(arr), count_(N) {}
+
+  template<class U, std::size_t N,
+    typename internal::is_span_convertable<element_type, Extent, U, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
+     : data_(arr.data()), count_(N) {}
+
+  //template<class U, std::size_t N,
+  //  int = 0>
+  //FLATBUFFERS_CONSTEXPR_CPP11 span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
+  //   : data_(arr.data()), count_(N) {}
+
+  template<class U, std::size_t N,
+    typename internal::is_span_convertable<element_type, Extent, U, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(const std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
+    : data_(arr.data()), count_(N) {}
+
+  // Converting constructor from another span s;
+  // the resulting span has size() == s.size() and data() == s.data().
+  // This overload only participates in overload resolution
+  // if extent == std::dynamic_extent || N == extent is true and U (*)[]
+  // is convertible to element_type (*)[].
+  template<class U, std::size_t N,
+    typename internal::is_span_convertable<element_type, Extent, U, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(const flatbuffers::span<U, N> &s) FLATBUFFERS_NOEXCEPT
+      : span(s.data(), s.size()) {
+  }
+
+  #endif  // !defined(FLATBUFFERS_SPAN_MINIMAL)
+
+ private:
+  // This is a naive implementation with 'count_' member even if (Extent != dynamic_extent).
+  pointer const data_;
+  const size_type count_;
+};
+
+ #if !defined(FLATBUFFERS_SPAN_MINIMAL)
+  template<class U, std::size_t N>
+  FLATBUFFERS_CONSTEXPR_CPP11
+  flatbuffers::span<U, N> make_span(U(&arr)[N]) FLATBUFFERS_NOEXCEPT {
+    return span<U, N>(arr);
+  }
+
+  template<class U, std::size_t N>
+  FLATBUFFERS_CONSTEXPR_CPP11
+  flatbuffers::span<const U, N> make_span(const U(&arr)[N]) FLATBUFFERS_NOEXCEPT {
+    return span<const U, N>(arr);
+  }
+
+  template<class U, std::size_t N>
+  FLATBUFFERS_CONSTEXPR_CPP11
+  flatbuffers::span<U, N> make_span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+    return span<U, N>(arr);
+  }
+
+  template<class U, std::size_t N>
+  FLATBUFFERS_CONSTEXPR_CPP11
+  flatbuffers::span<const U, N> make_span(const std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+    return span<const U, N>(arr);
+  }
+
+  template<class U, std::size_t N>
+  FLATBUFFERS_CONSTEXPR_CPP11
+  flatbuffers::span<U, dynamic_extent> make_span(U *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+    return span<U, dynamic_extent>(first, count);
+  }
+
+  template<class U, std::size_t N>
+  FLATBUFFERS_CONSTEXPR_CPP11
+  flatbuffers::span<const U, dynamic_extent> make_span(const U *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+    return span<const U, dynamic_extent>(first, count);
+  }
+#endif
+
+#endif  // defined(FLATBUFFERS_USE_STD_SPAN)
+
 }  // namespace flatbuffers
 
 #endif  // FLATBUFFERS_STL_EMULATION_H_
diff --git a/format/Schema.fbs b/format/Schema.fbs
index 3b00dd4780d..c449ba5f29f 100644
--- a/format/Schema.fbs
+++ b/format/Schema.fbs
@@ -147,6 +147,10 @@ table FloatingPoint {
   precision: Precision;
 }
 
+table Complex {
+  precision: Precision;
+}
+
 /// Unicode with UTF-8 encoding
 table Utf8 {
 }
@@ -302,6 +306,7 @@ union Type {
   LargeBinary,
   LargeUtf8,
   LargeList,
+  Complex
 }
 
 /// ----------------------------------------------------------------------