// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: substrait/type_expressions.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "substrait/type.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_substrait_2ftype_5fexpressions_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_substrait_2ftype_5fexpressions_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_5fexpressions_2eproto;
namespace substrait {
class DerivationExpression;
struct DerivationExpressionDefaultTypeInternal;
extern DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_;
class DerivationExpression_BinaryOp;
struct DerivationExpression_BinaryOpDefaultTypeInternal;
extern DerivationExpression_BinaryOpDefaultTypeInternal _DerivationExpression_BinaryOp_default_instance_;
class DerivationExpression_ExpressionDecimal;
struct DerivationExpression_ExpressionDecimalDefaultTypeInternal;
extern DerivationExpression_ExpressionDecimalDefaultTypeInternal _DerivationExpression_ExpressionDecimal_default_instance_;
class DerivationExpression_ExpressionFixedBinary;
struct DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal;
extern DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal _DerivationExpression_ExpressionFixedBinary_default_instance_;
class DerivationExpression_ExpressionFixedChar;
struct DerivationExpression_ExpressionFixedCharDefaultTypeInternal;
extern DerivationExpression_ExpressionFixedCharDefaultTypeInternal _DerivationExpression_ExpressionFixedChar_default_instance_;
class DerivationExpression_ExpressionList;
struct DerivationExpression_ExpressionListDefaultTypeInternal;
extern DerivationExpression_ExpressionListDefaultTypeInternal _DerivationExpression_ExpressionList_default_instance_;
class DerivationExpression_ExpressionMap;
struct DerivationExpression_ExpressionMapDefaultTypeInternal;
extern DerivationExpression_ExpressionMapDefaultTypeInternal _DerivationExpression_ExpressionMap_default_instance_;
class DerivationExpression_ExpressionNamedStruct;
struct DerivationExpression_ExpressionNamedStructDefaultTypeInternal;
extern DerivationExpression_ExpressionNamedStructDefaultTypeInternal _DerivationExpression_ExpressionNamedStruct_default_instance_;
class DerivationExpression_ExpressionStruct;
struct DerivationExpression_ExpressionStructDefaultTypeInternal;
extern DerivationExpression_ExpressionStructDefaultTypeInternal _DerivationExpression_ExpressionStruct_default_instance_;
class DerivationExpression_ExpressionVarChar;
struct DerivationExpression_ExpressionVarCharDefaultTypeInternal;
extern DerivationExpression_ExpressionVarCharDefaultTypeInternal _DerivationExpression_ExpressionVarChar_default_instance_;
class DerivationExpression_IfElse;
struct DerivationExpression_IfElseDefaultTypeInternal;
extern DerivationExpression_IfElseDefaultTypeInternal _DerivationExpression_IfElse_default_instance_;
class DerivationExpression_ReturnProgram;
struct DerivationExpression_ReturnProgramDefaultTypeInternal;
extern DerivationExpression_ReturnProgramDefaultTypeInternal _DerivationExpression_ReturnProgram_default_instance_;
class DerivationExpression_ReturnProgram_Assignment;
struct DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal;
extern DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal _DerivationExpression_ReturnProgram_Assignment_default_instance_;
class DerivationExpression_UnaryOp;
struct DerivationExpression_UnaryOpDefaultTypeInternal;
extern DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_;
}  // namespace substrait
PROTOBUF_NAMESPACE_OPEN
template<> ::substrait::DerivationExpression* Arena::CreateMaybeMessage<::substrait::DerivationExpression>(Arena*);
template<> ::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage<::substrait::DerivationExpression_BinaryOp>(Arena*);
template<> ::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionDecimal>(Arena*);
template<> ::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionFixedBinary>(Arena*);
template<> ::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionFixedChar>(Arena*);
template<> ::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionList>(Arena*);
template<> ::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionMap>(Arena*);
template<> ::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionNamedStruct>(Arena*);
template<> ::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(Arena*);
template<> ::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionVarChar>(Arena*);
template<> ::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage<::substrait::DerivationExpression_IfElse>(Arena*);
template<> ::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ReturnProgram>(Arena*);
template<> ::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ReturnProgram_Assignment>(Arena*);
template<> ::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage<::substrait::DerivationExpression_UnaryOp>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace substrait {

enum DerivationExpression_UnaryOp_UnaryOpType : int {
  DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED = 0,
  DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT = 1,
  DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value);
constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MIN = DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED;
constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX = DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT;
constexpr int DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_ARRAYSIZE = DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_UnaryOpType_descriptor();
template<typename T>
inline const std::string& DerivationExpression_UnaryOp_UnaryOpType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DerivationExpression_UnaryOp_UnaryOpType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DerivationExpression_UnaryOp_UnaryOpType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DerivationExpression_UnaryOp_UnaryOpType_descriptor(), enum_t_value);
}
inline bool DerivationExpression_UnaryOp_UnaryOpType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_UnaryOp_UnaryOpType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DerivationExpression_UnaryOp_UnaryOpType>(
    DerivationExpression_UnaryOp_UnaryOpType_descriptor(), name, value);
}
enum DerivationExpression_BinaryOp_BinaryOpType : int {
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED = 0,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_PLUS = 1,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MINUS = 2,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MULTIPLY = 3,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_DIVIDE = 4,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MIN = 5,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MAX = 6,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_GREATER_THAN = 7,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_LESS_THAN = 8,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_AND = 9,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_OR = 10,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_EQUALS = 11,
  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS = 12,
  DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value);
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MIN = DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX = DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS;
constexpr int DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_ARRAYSIZE = DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_BinaryOpType_descriptor();
template<typename T>
inline const std::string& DerivationExpression_BinaryOp_BinaryOpType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DerivationExpression_BinaryOp_BinaryOpType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DerivationExpression_BinaryOp_BinaryOpType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DerivationExpression_BinaryOp_BinaryOpType_descriptor(), enum_t_value);
}
inline bool DerivationExpression_BinaryOp_BinaryOpType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_BinaryOp_BinaryOpType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DerivationExpression_BinaryOp_BinaryOpType>(
    DerivationExpression_BinaryOp_BinaryOpType_descriptor(), name, value);
}
// ===================================================================

class DerivationExpression_ExpressionFixedChar final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedChar) */ {
 public:
  inline DerivationExpression_ExpressionFixedChar() : DerivationExpression_ExpressionFixedChar(nullptr) {}
  ~DerivationExpression_ExpressionFixedChar() override;
  explicit constexpr DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from);
  DerivationExpression_ExpressionFixedChar(DerivationExpression_ExpressionFixedChar&& from) noexcept
    : DerivationExpression_ExpressionFixedChar() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ExpressionFixedChar& operator=(const DerivationExpression_ExpressionFixedChar& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ExpressionFixedChar& operator=(DerivationExpression_ExpressionFixedChar&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ExpressionFixedChar& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ExpressionFixedChar* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ExpressionFixedChar*>(
               &_DerivationExpression_ExpressionFixedChar_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(DerivationExpression_ExpressionFixedChar& a, DerivationExpression_ExpressionFixedChar& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ExpressionFixedChar* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ExpressionFixedChar* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ExpressionFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ExpressionFixedChar>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ExpressionFixedChar& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ExpressionFixedChar& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ExpressionFixedChar* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ExpressionFixedChar";
  }
  protected:
  explicit DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLengthFieldNumber = 1,
    kVariationPointerFieldNumber = 2,
    kNullabilityFieldNumber = 3,
  };
  // .substrait.DerivationExpression length = 1 [json_name = "length"];
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  const ::substrait::DerivationExpression& length() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length();
  ::substrait::DerivationExpression* mutable_length();
  void set_allocated_length(::substrait::DerivationExpression* length);
  private:
  const ::substrait::DerivationExpression& _internal_length() const;
  ::substrait::DerivationExpression* _internal_mutable_length();
  public:
  void unsafe_arena_set_allocated_length(
      ::substrait::DerivationExpression* length);
  ::substrait::DerivationExpression* unsafe_arena_release_length();

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  void clear_variation_pointer();
  uint32_t variation_pointer() const;
  void set_variation_pointer(uint32_t value);
  private:
  uint32_t _internal_variation_pointer() const;
  void _internal_set_variation_pointer(uint32_t value);
  public:

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  void clear_nullability();
  ::substrait::Type_Nullability nullability() const;
  void set_nullability(::substrait::Type_Nullability value);
  private:
  ::substrait::Type_Nullability _internal_nullability() const;
  void _internal_set_nullability(::substrait::Type_Nullability value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionFixedChar)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::DerivationExpression* length_;
  uint32_t variation_pointer_;
  int nullability_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_ExpressionVarChar final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionVarChar) */ {
 public:
  inline DerivationExpression_ExpressionVarChar() : DerivationExpression_ExpressionVarChar(nullptr) {}
  ~DerivationExpression_ExpressionVarChar() override;
  explicit constexpr DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from);
  DerivationExpression_ExpressionVarChar(DerivationExpression_ExpressionVarChar&& from) noexcept
    : DerivationExpression_ExpressionVarChar() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ExpressionVarChar& operator=(const DerivationExpression_ExpressionVarChar& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ExpressionVarChar& operator=(DerivationExpression_ExpressionVarChar&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ExpressionVarChar& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ExpressionVarChar* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ExpressionVarChar*>(
               &_DerivationExpression_ExpressionVarChar_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(DerivationExpression_ExpressionVarChar& a, DerivationExpression_ExpressionVarChar& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ExpressionVarChar* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ExpressionVarChar* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ExpressionVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ExpressionVarChar>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ExpressionVarChar& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ExpressionVarChar& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ExpressionVarChar* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ExpressionVarChar";
  }
  protected:
  explicit DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLengthFieldNumber = 1,
    kVariationPointerFieldNumber = 2,
    kNullabilityFieldNumber = 3,
  };
  // .substrait.DerivationExpression length = 1 [json_name = "length"];
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  const ::substrait::DerivationExpression& length() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length();
  ::substrait::DerivationExpression* mutable_length();
  void set_allocated_length(::substrait::DerivationExpression* length);
  private:
  const ::substrait::DerivationExpression& _internal_length() const;
  ::substrait::DerivationExpression* _internal_mutable_length();
  public:
  void unsafe_arena_set_allocated_length(
      ::substrait::DerivationExpression* length);
  ::substrait::DerivationExpression* unsafe_arena_release_length();

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  void clear_variation_pointer();
  uint32_t variation_pointer() const;
  void set_variation_pointer(uint32_t value);
  private:
  uint32_t _internal_variation_pointer() const;
  void _internal_set_variation_pointer(uint32_t value);
  public:

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  void clear_nullability();
  ::substrait::Type_Nullability nullability() const;
  void set_nullability(::substrait::Type_Nullability value);
  private:
  ::substrait::Type_Nullability _internal_nullability() const;
  void _internal_set_nullability(::substrait::Type_Nullability value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionVarChar)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::DerivationExpression* length_;
  uint32_t variation_pointer_;
  int nullability_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_ExpressionFixedBinary final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedBinary) */ {
 public:
  inline DerivationExpression_ExpressionFixedBinary() : DerivationExpression_ExpressionFixedBinary(nullptr) {}
  ~DerivationExpression_ExpressionFixedBinary() override;
  explicit constexpr DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from);
  DerivationExpression_ExpressionFixedBinary(DerivationExpression_ExpressionFixedBinary&& from) noexcept
    : DerivationExpression_ExpressionFixedBinary() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ExpressionFixedBinary& operator=(const DerivationExpression_ExpressionFixedBinary& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ExpressionFixedBinary& operator=(DerivationExpression_ExpressionFixedBinary&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ExpressionFixedBinary& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ExpressionFixedBinary* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ExpressionFixedBinary*>(
               &_DerivationExpression_ExpressionFixedBinary_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(DerivationExpression_ExpressionFixedBinary& a, DerivationExpression_ExpressionFixedBinary& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ExpressionFixedBinary* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ExpressionFixedBinary* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ExpressionFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ExpressionFixedBinary>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ExpressionFixedBinary& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ExpressionFixedBinary& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ExpressionFixedBinary* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ExpressionFixedBinary";
  }
  protected:
  explicit DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLengthFieldNumber = 1,
    kVariationPointerFieldNumber = 2,
    kNullabilityFieldNumber = 3,
  };
  // .substrait.DerivationExpression length = 1 [json_name = "length"];
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  const ::substrait::DerivationExpression& length() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length();
  ::substrait::DerivationExpression* mutable_length();
  void set_allocated_length(::substrait::DerivationExpression* length);
  private:
  const ::substrait::DerivationExpression& _internal_length() const;
  ::substrait::DerivationExpression* _internal_mutable_length();
  public:
  void unsafe_arena_set_allocated_length(
      ::substrait::DerivationExpression* length);
  ::substrait::DerivationExpression* unsafe_arena_release_length();

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  void clear_variation_pointer();
  uint32_t variation_pointer() const;
  void set_variation_pointer(uint32_t value);
  private:
  uint32_t _internal_variation_pointer() const;
  void _internal_set_variation_pointer(uint32_t value);
  public:

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  void clear_nullability();
  ::substrait::Type_Nullability nullability() const;
  void set_nullability(::substrait::Type_Nullability value);
  private:
  ::substrait::Type_Nullability _internal_nullability() const;
  void _internal_set_nullability(::substrait::Type_Nullability value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionFixedBinary)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::DerivationExpression* length_;
  uint32_t variation_pointer_;
  int nullability_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_ExpressionDecimal final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionDecimal) */ {
 public:
  inline DerivationExpression_ExpressionDecimal() : DerivationExpression_ExpressionDecimal(nullptr) {}
  ~DerivationExpression_ExpressionDecimal() override;
  explicit constexpr DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from);
  DerivationExpression_ExpressionDecimal(DerivationExpression_ExpressionDecimal&& from) noexcept
    : DerivationExpression_ExpressionDecimal() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ExpressionDecimal& operator=(const DerivationExpression_ExpressionDecimal& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ExpressionDecimal& operator=(DerivationExpression_ExpressionDecimal&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ExpressionDecimal& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ExpressionDecimal* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ExpressionDecimal*>(
               &_DerivationExpression_ExpressionDecimal_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(DerivationExpression_ExpressionDecimal& a, DerivationExpression_ExpressionDecimal& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ExpressionDecimal* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ExpressionDecimal* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ExpressionDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ExpressionDecimal>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ExpressionDecimal& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ExpressionDecimal& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ExpressionDecimal* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ExpressionDecimal";
  }
  protected:
  explicit DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kScaleFieldNumber = 1,
    kPrecisionFieldNumber = 2,
    kVariationPointerFieldNumber = 3,
    kNullabilityFieldNumber = 4,
  };
  // .substrait.DerivationExpression scale = 1 [json_name = "scale"];
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  const ::substrait::DerivationExpression& scale() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_scale();
  ::substrait::DerivationExpression* mutable_scale();
  void set_allocated_scale(::substrait::DerivationExpression* scale);
  private:
  const ::substrait::DerivationExpression& _internal_scale() const;
  ::substrait::DerivationExpression* _internal_mutable_scale();
  public:
  void unsafe_arena_set_allocated_scale(
      ::substrait::DerivationExpression* scale);
  ::substrait::DerivationExpression* unsafe_arena_release_scale();

  // .substrait.DerivationExpression precision = 2 [json_name = "precision"];
  bool has_precision() const;
  private:
  bool _internal_has_precision() const;
  public:
  void clear_precision();
  const ::substrait::DerivationExpression& precision() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_precision();
  ::substrait::DerivationExpression* mutable_precision();
  void set_allocated_precision(::substrait::DerivationExpression* precision);
  private:
  const ::substrait::DerivationExpression& _internal_precision() const;
  ::substrait::DerivationExpression* _internal_mutable_precision();
  public:
  void unsafe_arena_set_allocated_precision(
      ::substrait::DerivationExpression* precision);
  ::substrait::DerivationExpression* unsafe_arena_release_precision();

  // uint32 variation_pointer = 3 [json_name = "variationPointer"];
  void clear_variation_pointer();
  uint32_t variation_pointer() const;
  void set_variation_pointer(uint32_t value);
  private:
  uint32_t _internal_variation_pointer() const;
  void _internal_set_variation_pointer(uint32_t value);
  public:

  // .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
  void clear_nullability();
  ::substrait::Type_Nullability nullability() const;
  void set_nullability(::substrait::Type_Nullability value);
  private:
  ::substrait::Type_Nullability _internal_nullability() const;
  void _internal_set_nullability(::substrait::Type_Nullability value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionDecimal)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::DerivationExpression* scale_;
  ::substrait::DerivationExpression* precision_;
  uint32_t variation_pointer_;
  int nullability_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_ExpressionStruct final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionStruct) */ {
 public:
  inline DerivationExpression_ExpressionStruct() : DerivationExpression_ExpressionStruct(nullptr) {}
  ~DerivationExpression_ExpressionStruct() override;
  explicit constexpr DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from);
  DerivationExpression_ExpressionStruct(DerivationExpression_ExpressionStruct&& from) noexcept
    : DerivationExpression_ExpressionStruct() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ExpressionStruct& operator=(const DerivationExpression_ExpressionStruct& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ExpressionStruct& operator=(DerivationExpression_ExpressionStruct&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ExpressionStruct& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ExpressionStruct* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ExpressionStruct*>(
               &_DerivationExpression_ExpressionStruct_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(DerivationExpression_ExpressionStruct& a, DerivationExpression_ExpressionStruct& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ExpressionStruct* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ExpressionStruct* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ExpressionStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ExpressionStruct>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ExpressionStruct& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ExpressionStruct& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ExpressionStruct* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ExpressionStruct";
  }
  protected:
  explicit DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTypesFieldNumber = 1,
    kVariationPointerFieldNumber = 2,
    kNullabilityFieldNumber = 3,
  };
  // repeated .substrait.DerivationExpression types = 1 [json_name = "types"];
  int types_size() const;
  private:
  int _internal_types_size() const;
  public:
  void clear_types();
  ::substrait::DerivationExpression* mutable_types(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >*
      mutable_types();
  private:
  const ::substrait::DerivationExpression& _internal_types(int index) const;
  ::substrait::DerivationExpression* _internal_add_types();
  public:
  const ::substrait::DerivationExpression& types(int index) const;
  ::substrait::DerivationExpression* add_types();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >&
      types() const;

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  void clear_variation_pointer();
  uint32_t variation_pointer() const;
  void set_variation_pointer(uint32_t value);
  private:
  uint32_t _internal_variation_pointer() const;
  void _internal_set_variation_pointer(uint32_t value);
  public:

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  void clear_nullability();
  ::substrait::Type_Nullability nullability() const;
  void set_nullability(::substrait::Type_Nullability value);
  private:
  ::substrait::Type_Nullability _internal_nullability() const;
  void _internal_set_nullability(::substrait::Type_Nullability value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionStruct)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression > types_;
  uint32_t variation_pointer_;
  int nullability_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_ExpressionNamedStruct final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionNamedStruct) */ {
 public:
  inline DerivationExpression_ExpressionNamedStruct() : DerivationExpression_ExpressionNamedStruct(nullptr) {}
  ~DerivationExpression_ExpressionNamedStruct() override;
  explicit constexpr DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from);
  DerivationExpression_ExpressionNamedStruct(DerivationExpression_ExpressionNamedStruct&& from) noexcept
    : DerivationExpression_ExpressionNamedStruct() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ExpressionNamedStruct& operator=(const DerivationExpression_ExpressionNamedStruct& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ExpressionNamedStruct& operator=(DerivationExpression_ExpressionNamedStruct&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ExpressionNamedStruct& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ExpressionNamedStruct* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ExpressionNamedStruct*>(
               &_DerivationExpression_ExpressionNamedStruct_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(DerivationExpression_ExpressionNamedStruct& a, DerivationExpression_ExpressionNamedStruct& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ExpressionNamedStruct* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ExpressionNamedStruct* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ExpressionNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ExpressionNamedStruct>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ExpressionNamedStruct& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ExpressionNamedStruct& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ExpressionNamedStruct* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ExpressionNamedStruct";
  }
  protected:
  explicit DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNamesFieldNumber = 1,
    kStructFieldNumber = 2,
  };
  // repeated string names = 1 [json_name = "names"];
  int names_size() const;
  private:
  int _internal_names_size() const;
  public:
  void clear_names();
  const std::string& names(int index) const;
  std::string* mutable_names(int index);
  void set_names(int index, const std::string& value);
  void set_names(int index, std::string&& value);
  void set_names(int index, const char* value);
  void set_names(int index, const char* value, size_t size);
  std::string* add_names();
  void add_names(const std::string& value);
  void add_names(std::string&& value);
  void add_names(const char* value);
  void add_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_names();
  private:
  const std::string& _internal_names(int index) const;
  std::string* _internal_add_names();
  public:

  // .substrait.DerivationExpression.ExpressionStruct struct = 2 [json_name = "struct"];
  bool has_struct_() const;
  private:
  bool _internal_has_struct_() const;
  public:
  void clear_struct_();
  const ::substrait::DerivationExpression_ExpressionStruct& struct_() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionStruct* release_struct_();
  ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_();
  void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_);
  private:
  const ::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const;
  ::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_();
  public:
  void unsafe_arena_set_allocated_struct_(
      ::substrait::DerivationExpression_ExpressionStruct* struct_);
  ::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_();

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionNamedStruct)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> names_;
  ::substrait::DerivationExpression_ExpressionStruct* struct__;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_ExpressionList final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionList) */ {
 public:
  inline DerivationExpression_ExpressionList() : DerivationExpression_ExpressionList(nullptr) {}
  ~DerivationExpression_ExpressionList() override;
  explicit constexpr DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from);
  DerivationExpression_ExpressionList(DerivationExpression_ExpressionList&& from) noexcept
    : DerivationExpression_ExpressionList() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ExpressionList& operator=(const DerivationExpression_ExpressionList& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ExpressionList& operator=(DerivationExpression_ExpressionList&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ExpressionList& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ExpressionList* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ExpressionList*>(
               &_DerivationExpression_ExpressionList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(DerivationExpression_ExpressionList& a, DerivationExpression_ExpressionList& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ExpressionList* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ExpressionList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ExpressionList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ExpressionList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ExpressionList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ExpressionList& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ExpressionList* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ExpressionList";
  }
  protected:
  explicit DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTypeFieldNumber = 1,
    kVariationPointerFieldNumber = 2,
    kNullabilityFieldNumber = 3,
  };
  // .substrait.DerivationExpression type = 1 [json_name = "type"];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const ::substrait::DerivationExpression& type() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_type();
  ::substrait::DerivationExpression* mutable_type();
  void set_allocated_type(::substrait::DerivationExpression* type);
  private:
  const ::substrait::DerivationExpression& _internal_type() const;
  ::substrait::DerivationExpression* _internal_mutable_type();
  public:
  void unsafe_arena_set_allocated_type(
      ::substrait::DerivationExpression* type);
  ::substrait::DerivationExpression* unsafe_arena_release_type();

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  void clear_variation_pointer();
  uint32_t variation_pointer() const;
  void set_variation_pointer(uint32_t value);
  private:
  uint32_t _internal_variation_pointer() const;
  void _internal_set_variation_pointer(uint32_t value);
  public:

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  void clear_nullability();
  ::substrait::Type_Nullability nullability() const;
  void set_nullability(::substrait::Type_Nullability value);
  private:
  ::substrait::Type_Nullability _internal_nullability() const;
  void _internal_set_nullability(::substrait::Type_Nullability value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::DerivationExpression* type_;
  uint32_t variation_pointer_;
  int nullability_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_ExpressionMap final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionMap) */ {
 public:
  inline DerivationExpression_ExpressionMap() : DerivationExpression_ExpressionMap(nullptr) {}
  ~DerivationExpression_ExpressionMap() override;
  explicit constexpr DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from);
  DerivationExpression_ExpressionMap(DerivationExpression_ExpressionMap&& from) noexcept
    : DerivationExpression_ExpressionMap() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ExpressionMap& operator=(const DerivationExpression_ExpressionMap& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ExpressionMap& operator=(DerivationExpression_ExpressionMap&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ExpressionMap& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ExpressionMap* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ExpressionMap*>(
               &_DerivationExpression_ExpressionMap_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(DerivationExpression_ExpressionMap& a, DerivationExpression_ExpressionMap& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ExpressionMap* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ExpressionMap* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ExpressionMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ExpressionMap>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ExpressionMap& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ExpressionMap& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ExpressionMap* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ExpressionMap";
  }
  protected:
  explicit DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
    kVariationPointerFieldNumber = 3,
    kNullabilityFieldNumber = 4,
  };
  // .substrait.DerivationExpression key = 1 [json_name = "key"];
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::substrait::DerivationExpression& key() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_key();
  ::substrait::DerivationExpression* mutable_key();
  void set_allocated_key(::substrait::DerivationExpression* key);
  private:
  const ::substrait::DerivationExpression& _internal_key() const;
  ::substrait::DerivationExpression* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::substrait::DerivationExpression* key);
  ::substrait::DerivationExpression* unsafe_arena_release_key();

  // .substrait.DerivationExpression value = 2 [json_name = "value"];
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::substrait::DerivationExpression& value() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_value();
  ::substrait::DerivationExpression* mutable_value();
  void set_allocated_value(::substrait::DerivationExpression* value);
  private:
  const ::substrait::DerivationExpression& _internal_value() const;
  ::substrait::DerivationExpression* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::substrait::DerivationExpression* value);
  ::substrait::DerivationExpression* unsafe_arena_release_value();

  // uint32 variation_pointer = 3 [json_name = "variationPointer"];
  void clear_variation_pointer();
  uint32_t variation_pointer() const;
  void set_variation_pointer(uint32_t value);
  private:
  uint32_t _internal_variation_pointer() const;
  void _internal_set_variation_pointer(uint32_t value);
  public:

  // .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
  void clear_nullability();
  ::substrait::Type_Nullability nullability() const;
  void set_nullability(::substrait::Type_Nullability value);
  private:
  ::substrait::Type_Nullability _internal_nullability() const;
  void _internal_set_nullability(::substrait::Type_Nullability value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionMap)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::DerivationExpression* key_;
  ::substrait::DerivationExpression* value_;
  uint32_t variation_pointer_;
  int nullability_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_IfElse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.IfElse) */ {
 public:
  inline DerivationExpression_IfElse() : DerivationExpression_IfElse(nullptr) {}
  ~DerivationExpression_IfElse() override;
  explicit constexpr DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_IfElse(const DerivationExpression_IfElse& from);
  DerivationExpression_IfElse(DerivationExpression_IfElse&& from) noexcept
    : DerivationExpression_IfElse() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_IfElse& operator=(const DerivationExpression_IfElse& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_IfElse& operator=(DerivationExpression_IfElse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_IfElse& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_IfElse* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_IfElse*>(
               &_DerivationExpression_IfElse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(DerivationExpression_IfElse& a, DerivationExpression_IfElse& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_IfElse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_IfElse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_IfElse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_IfElse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_IfElse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_IfElse& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_IfElse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.IfElse";
  }
  protected:
  explicit DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIfConditionFieldNumber = 1,
    kIfReturnFieldNumber = 2,
    kElseReturnFieldNumber = 3,
  };
  // .substrait.DerivationExpression if_condition = 1 [json_name = "ifCondition"];
  bool has_if_condition() const;
  private:
  bool _internal_has_if_condition() const;
  public:
  void clear_if_condition();
  const ::substrait::DerivationExpression& if_condition() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_if_condition();
  ::substrait::DerivationExpression* mutable_if_condition();
  void set_allocated_if_condition(::substrait::DerivationExpression* if_condition);
  private:
  const ::substrait::DerivationExpression& _internal_if_condition() const;
  ::substrait::DerivationExpression* _internal_mutable_if_condition();
  public:
  void unsafe_arena_set_allocated_if_condition(
      ::substrait::DerivationExpression* if_condition);
  ::substrait::DerivationExpression* unsafe_arena_release_if_condition();

  // .substrait.DerivationExpression if_return = 2 [json_name = "ifReturn"];
  bool has_if_return() const;
  private:
  bool _internal_has_if_return() const;
  public:
  void clear_if_return();
  const ::substrait::DerivationExpression& if_return() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_if_return();
  ::substrait::DerivationExpression* mutable_if_return();
  void set_allocated_if_return(::substrait::DerivationExpression* if_return);
  private:
  const ::substrait::DerivationExpression& _internal_if_return() const;
  ::substrait::DerivationExpression* _internal_mutable_if_return();
  public:
  void unsafe_arena_set_allocated_if_return(
      ::substrait::DerivationExpression* if_return);
  ::substrait::DerivationExpression* unsafe_arena_release_if_return();

  // .substrait.DerivationExpression else_return = 3 [json_name = "elseReturn"];
  bool has_else_return() const;
  private:
  bool _internal_has_else_return() const;
  public:
  void clear_else_return();
  const ::substrait::DerivationExpression& else_return() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_else_return();
  ::substrait::DerivationExpression* mutable_else_return();
  void set_allocated_else_return(::substrait::DerivationExpression* else_return);
  private:
  const ::substrait::DerivationExpression& _internal_else_return() const;
  ::substrait::DerivationExpression* _internal_mutable_else_return();
  public:
  void unsafe_arena_set_allocated_else_return(
      ::substrait::DerivationExpression* else_return);
  ::substrait::DerivationExpression* unsafe_arena_release_else_return();

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.IfElse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::DerivationExpression* if_condition_;
  ::substrait::DerivationExpression* if_return_;
  ::substrait::DerivationExpression* else_return_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_UnaryOp final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.UnaryOp) */ {
 public:
  inline DerivationExpression_UnaryOp() : DerivationExpression_UnaryOp(nullptr) {}
  ~DerivationExpression_UnaryOp() override;
  explicit constexpr DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from);
  DerivationExpression_UnaryOp(DerivationExpression_UnaryOp&& from) noexcept
    : DerivationExpression_UnaryOp() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_UnaryOp& operator=(const DerivationExpression_UnaryOp& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_UnaryOp& operator=(DerivationExpression_UnaryOp&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_UnaryOp& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_UnaryOp* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_UnaryOp*>(
               &_DerivationExpression_UnaryOp_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(DerivationExpression_UnaryOp& a, DerivationExpression_UnaryOp& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_UnaryOp* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_UnaryOp* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_UnaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_UnaryOp>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_UnaryOp& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_UnaryOp& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_UnaryOp* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.UnaryOp";
  }
  protected:
  explicit DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef DerivationExpression_UnaryOp_UnaryOpType UnaryOpType;
  static constexpr UnaryOpType UNARY_OP_TYPE_UNSPECIFIED =
    DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED;
  static constexpr UnaryOpType UNARY_OP_TYPE_BOOLEAN_NOT =
    DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT;
  static inline bool UnaryOpType_IsValid(int value) {
    return DerivationExpression_UnaryOp_UnaryOpType_IsValid(value);
  }
  static constexpr UnaryOpType UnaryOpType_MIN =
    DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MIN;
  static constexpr UnaryOpType UnaryOpType_MAX =
    DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX;
  static constexpr int UnaryOpType_ARRAYSIZE =
    DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  UnaryOpType_descriptor() {
    return DerivationExpression_UnaryOp_UnaryOpType_descriptor();
  }
  template<typename T>
  static inline const std::string& UnaryOpType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, UnaryOpType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function UnaryOpType_Name.");
    return DerivationExpression_UnaryOp_UnaryOpType_Name(enum_t_value);
  }
  static inline bool UnaryOpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      UnaryOpType* value) {
    return DerivationExpression_UnaryOp_UnaryOpType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kArgFieldNumber = 2,
    kOpTypeFieldNumber = 1,
  };
  // .substrait.DerivationExpression arg = 2 [json_name = "arg"];
  bool has_arg() const;
  private:
  bool _internal_has_arg() const;
  public:
  void clear_arg();
  const ::substrait::DerivationExpression& arg() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg();
  ::substrait::DerivationExpression* mutable_arg();
  void set_allocated_arg(::substrait::DerivationExpression* arg);
  private:
  const ::substrait::DerivationExpression& _internal_arg() const;
  ::substrait::DerivationExpression* _internal_mutable_arg();
  public:
  void unsafe_arena_set_allocated_arg(
      ::substrait::DerivationExpression* arg);
  ::substrait::DerivationExpression* unsafe_arena_release_arg();

  // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1 [json_name = "opType"];
  void clear_op_type();
  ::substrait::DerivationExpression_UnaryOp_UnaryOpType op_type() const;
  void set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value);
  private:
  ::substrait::DerivationExpression_UnaryOp_UnaryOpType _internal_op_type() const;
  void _internal_set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.UnaryOp)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::DerivationExpression* arg_;
  int op_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_BinaryOp final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.BinaryOp) */ {
 public:
  inline DerivationExpression_BinaryOp() : DerivationExpression_BinaryOp(nullptr) {}
  ~DerivationExpression_BinaryOp() override;
  explicit constexpr DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from);
  DerivationExpression_BinaryOp(DerivationExpression_BinaryOp&& from) noexcept
    : DerivationExpression_BinaryOp() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_BinaryOp& operator=(const DerivationExpression_BinaryOp& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_BinaryOp& operator=(DerivationExpression_BinaryOp&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_BinaryOp& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_BinaryOp* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_BinaryOp*>(
               &_DerivationExpression_BinaryOp_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(DerivationExpression_BinaryOp& a, DerivationExpression_BinaryOp& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_BinaryOp* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_BinaryOp* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_BinaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_BinaryOp>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_BinaryOp& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_BinaryOp& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_BinaryOp* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.BinaryOp";
  }
  protected:
  explicit DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef DerivationExpression_BinaryOp_BinaryOpType BinaryOpType;
  static constexpr BinaryOpType BINARY_OP_TYPE_UNSPECIFIED =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED;
  static constexpr BinaryOpType BINARY_OP_TYPE_PLUS =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_PLUS;
  static constexpr BinaryOpType BINARY_OP_TYPE_MINUS =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MINUS;
  static constexpr BinaryOpType BINARY_OP_TYPE_MULTIPLY =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MULTIPLY;
  static constexpr BinaryOpType BINARY_OP_TYPE_DIVIDE =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_DIVIDE;
  static constexpr BinaryOpType BINARY_OP_TYPE_MIN =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MIN;
  static constexpr BinaryOpType BINARY_OP_TYPE_MAX =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MAX;
  static constexpr BinaryOpType BINARY_OP_TYPE_GREATER_THAN =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_GREATER_THAN;
  static constexpr BinaryOpType BINARY_OP_TYPE_LESS_THAN =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_LESS_THAN;
  static constexpr BinaryOpType BINARY_OP_TYPE_AND =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_AND;
  static constexpr BinaryOpType BINARY_OP_TYPE_OR =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_OR;
  static constexpr BinaryOpType BINARY_OP_TYPE_EQUALS =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_EQUALS;
  static constexpr BinaryOpType BINARY_OP_TYPE_COVERS =
    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS;
  static inline bool BinaryOpType_IsValid(int value) {
    return DerivationExpression_BinaryOp_BinaryOpType_IsValid(value);
  }
  static constexpr BinaryOpType BinaryOpType_MIN =
    DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MIN;
  static constexpr BinaryOpType BinaryOpType_MAX =
    DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX;
  static constexpr int BinaryOpType_ARRAYSIZE =
    DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  BinaryOpType_descriptor() {
    return DerivationExpression_BinaryOp_BinaryOpType_descriptor();
  }
  template<typename T>
  static inline const std::string& BinaryOpType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BinaryOpType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BinaryOpType_Name.");
    return DerivationExpression_BinaryOp_BinaryOpType_Name(enum_t_value);
  }
  static inline bool BinaryOpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      BinaryOpType* value) {
    return DerivationExpression_BinaryOp_BinaryOpType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kArg1FieldNumber = 2,
    kArg2FieldNumber = 3,
    kOpTypeFieldNumber = 1,
  };
  // .substrait.DerivationExpression arg1 = 2 [json_name = "arg1"];
  bool has_arg1() const;
  private:
  bool _internal_has_arg1() const;
  public:
  void clear_arg1();
  const ::substrait::DerivationExpression& arg1() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg1();
  ::substrait::DerivationExpression* mutable_arg1();
  void set_allocated_arg1(::substrait::DerivationExpression* arg1);
  private:
  const ::substrait::DerivationExpression& _internal_arg1() const;
  ::substrait::DerivationExpression* _internal_mutable_arg1();
  public:
  void unsafe_arena_set_allocated_arg1(
      ::substrait::DerivationExpression* arg1);
  ::substrait::DerivationExpression* unsafe_arena_release_arg1();

  // .substrait.DerivationExpression arg2 = 3 [json_name = "arg2"];
  bool has_arg2() const;
  private:
  bool _internal_has_arg2() const;
  public:
  void clear_arg2();
  const ::substrait::DerivationExpression& arg2() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg2();
  ::substrait::DerivationExpression* mutable_arg2();
  void set_allocated_arg2(::substrait::DerivationExpression* arg2);
  private:
  const ::substrait::DerivationExpression& _internal_arg2() const;
  ::substrait::DerivationExpression* _internal_mutable_arg2();
  public:
  void unsafe_arena_set_allocated_arg2(
      ::substrait::DerivationExpression* arg2);
  ::substrait::DerivationExpression* unsafe_arena_release_arg2();

  // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1 [json_name = "opType"];
  void clear_op_type();
  ::substrait::DerivationExpression_BinaryOp_BinaryOpType op_type() const;
  void set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value);
  private:
  ::substrait::DerivationExpression_BinaryOp_BinaryOpType _internal_op_type() const;
  void _internal_set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.BinaryOp)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::DerivationExpression* arg1_;
  ::substrait::DerivationExpression* arg2_;
  int op_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_ReturnProgram_Assignment final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram.Assignment) */ {
 public:
  inline DerivationExpression_ReturnProgram_Assignment() : DerivationExpression_ReturnProgram_Assignment(nullptr) {}
  ~DerivationExpression_ReturnProgram_Assignment() override;
  explicit constexpr DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from);
  DerivationExpression_ReturnProgram_Assignment(DerivationExpression_ReturnProgram_Assignment&& from) noexcept
    : DerivationExpression_ReturnProgram_Assignment() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ReturnProgram_Assignment& operator=(const DerivationExpression_ReturnProgram_Assignment& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ReturnProgram_Assignment& operator=(DerivationExpression_ReturnProgram_Assignment&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ReturnProgram_Assignment& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ReturnProgram_Assignment* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ReturnProgram_Assignment*>(
               &_DerivationExpression_ReturnProgram_Assignment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(DerivationExpression_ReturnProgram_Assignment& a, DerivationExpression_ReturnProgram_Assignment& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ReturnProgram_Assignment* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ReturnProgram_Assignment* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ReturnProgram_Assignment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ReturnProgram_Assignment>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ReturnProgram_Assignment* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ReturnProgram.Assignment";
  }
  protected:
  explicit DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kExpressionFieldNumber = 2,
  };
  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .substrait.DerivationExpression expression = 2 [json_name = "expression"];
  bool has_expression() const;
  private:
  bool _internal_has_expression() const;
  public:
  void clear_expression();
  const ::substrait::DerivationExpression& expression() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_expression();
  ::substrait::DerivationExpression* mutable_expression();
  void set_allocated_expression(::substrait::DerivationExpression* expression);
  private:
  const ::substrait::DerivationExpression& _internal_expression() const;
  ::substrait::DerivationExpression* _internal_mutable_expression();
  public:
  void unsafe_arena_set_allocated_expression(
      ::substrait::DerivationExpression* expression);
  ::substrait::DerivationExpression* unsafe_arena_release_expression();

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ReturnProgram.Assignment)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::substrait::DerivationExpression* expression_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression_ReturnProgram final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram) */ {
 public:
  inline DerivationExpression_ReturnProgram() : DerivationExpression_ReturnProgram(nullptr) {}
  ~DerivationExpression_ReturnProgram() override;
  explicit constexpr DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from);
  DerivationExpression_ReturnProgram(DerivationExpression_ReturnProgram&& from) noexcept
    : DerivationExpression_ReturnProgram() {
    *this = ::std::move(from);
  }

  inline DerivationExpression_ReturnProgram& operator=(const DerivationExpression_ReturnProgram& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression_ReturnProgram& operator=(DerivationExpression_ReturnProgram&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression_ReturnProgram& default_instance() {
    return *internal_default_instance();
  }
  static inline const DerivationExpression_ReturnProgram* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression_ReturnProgram*>(
               &_DerivationExpression_ReturnProgram_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(DerivationExpression_ReturnProgram& a, DerivationExpression_ReturnProgram& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression_ReturnProgram* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression_ReturnProgram* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression_ReturnProgram* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression_ReturnProgram>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression_ReturnProgram& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression_ReturnProgram& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression_ReturnProgram* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression.ReturnProgram";
  }
  protected:
  explicit DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef DerivationExpression_ReturnProgram_Assignment Assignment;

  // accessors -------------------------------------------------------

  enum : int {
    kAssignmentsFieldNumber = 1,
    kFinalExpressionFieldNumber = 2,
  };
  // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1 [json_name = "assignments"];
  int assignments_size() const;
  private:
  int _internal_assignments_size() const;
  public:
  void clear_assignments();
  ::substrait::DerivationExpression_ReturnProgram_Assignment* mutable_assignments(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >*
      mutable_assignments();
  private:
  const ::substrait::DerivationExpression_ReturnProgram_Assignment& _internal_assignments(int index) const;
  ::substrait::DerivationExpression_ReturnProgram_Assignment* _internal_add_assignments();
  public:
  const ::substrait::DerivationExpression_ReturnProgram_Assignment& assignments(int index) const;
  ::substrait::DerivationExpression_ReturnProgram_Assignment* add_assignments();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >&
      assignments() const;

  // .substrait.DerivationExpression final_expression = 2 [json_name = "finalExpression"];
  bool has_final_expression() const;
  private:
  bool _internal_has_final_expression() const;
  public:
  void clear_final_expression();
  const ::substrait::DerivationExpression& final_expression() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_final_expression();
  ::substrait::DerivationExpression* mutable_final_expression();
  void set_allocated_final_expression(::substrait::DerivationExpression* final_expression);
  private:
  const ::substrait::DerivationExpression& _internal_final_expression() const;
  ::substrait::DerivationExpression* _internal_mutable_final_expression();
  public:
  void unsafe_arena_set_allocated_final_expression(
      ::substrait::DerivationExpression* final_expression);
  ::substrait::DerivationExpression* unsafe_arena_release_final_expression();

  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ReturnProgram)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment > assignments_;
  ::substrait::DerivationExpression* final_expression_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// -------------------------------------------------------------------

class DerivationExpression final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression) */ {
 public:
  inline DerivationExpression() : DerivationExpression(nullptr) {}
  ~DerivationExpression() override;
  explicit constexpr DerivationExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DerivationExpression(const DerivationExpression& from);
  DerivationExpression(DerivationExpression&& from) noexcept
    : DerivationExpression() {
    *this = ::std::move(from);
  }

  inline DerivationExpression& operator=(const DerivationExpression& from) {
    CopyFrom(from);
    return *this;
  }
  inline DerivationExpression& operator=(DerivationExpression&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DerivationExpression& default_instance() {
    return *internal_default_instance();
  }
  enum KindCase {
    kBool = 1,
    kI8 = 2,
    kI16 = 3,
    kI32 = 5,
    kI64 = 7,
    kFp32 = 10,
    kFp64 = 11,
    kString = 12,
    kBinary = 13,
    kTimestamp = 14,
    kDate = 16,
    kTime = 17,
    kIntervalYear = 19,
    kIntervalDay = 20,
    kTimestampTz = 29,
    kUuid = 32,
    kFixedChar = 21,
    kVarchar = 22,
    kFixedBinary = 23,
    kDecimal = 24,
    kStruct = 25,
    kList = 27,
    kMap = 28,
    kUserDefinedPointer = 31,
    kTypeParameterName = 33,
    kIntegerParameterName = 34,
    kIntegerLiteral = 35,
    kUnaryOp = 36,
    kBinaryOp = 37,
    kIfElse = 38,
    kReturnProgram = 39,
    KIND_NOT_SET = 0,
  };

  static inline const DerivationExpression* internal_default_instance() {
    return reinterpret_cast<const DerivationExpression*>(
               &_DerivationExpression_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(DerivationExpression& a, DerivationExpression& b) {
    a.Swap(&b);
  }
  inline void Swap(DerivationExpression* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DerivationExpression* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DerivationExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DerivationExpression>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DerivationExpression& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DerivationExpression& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DerivationExpression* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.DerivationExpression";
  }
  protected:
  explicit DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef DerivationExpression_ExpressionFixedChar ExpressionFixedChar;
  typedef DerivationExpression_ExpressionVarChar ExpressionVarChar;
  typedef DerivationExpression_ExpressionFixedBinary ExpressionFixedBinary;
  typedef DerivationExpression_ExpressionDecimal ExpressionDecimal;
  typedef DerivationExpression_ExpressionStruct ExpressionStruct;
  typedef DerivationExpression_ExpressionNamedStruct ExpressionNamedStruct;
  typedef DerivationExpression_ExpressionList ExpressionList;
  typedef DerivationExpression_ExpressionMap ExpressionMap;
  typedef DerivationExpression_IfElse IfElse;
  typedef DerivationExpression_UnaryOp UnaryOp;
  typedef DerivationExpression_BinaryOp BinaryOp;
  typedef DerivationExpression_ReturnProgram ReturnProgram;

  // accessors -------------------------------------------------------

  enum : int {
    kBoolFieldNumber = 1,
    kI8FieldNumber = 2,
    kI16FieldNumber = 3,
    kI32FieldNumber = 5,
    kI64FieldNumber = 7,
    kFp32FieldNumber = 10,
    kFp64FieldNumber = 11,
    kStringFieldNumber = 12,
    kBinaryFieldNumber = 13,
    kTimestampFieldNumber = 14,
    kDateFieldNumber = 16,
    kTimeFieldNumber = 17,
    kIntervalYearFieldNumber = 19,
    kIntervalDayFieldNumber = 20,
    kTimestampTzFieldNumber = 29,
    kUuidFieldNumber = 32,
    kFixedCharFieldNumber = 21,
    kVarcharFieldNumber = 22,
    kFixedBinaryFieldNumber = 23,
    kDecimalFieldNumber = 24,
    kStructFieldNumber = 25,
    kListFieldNumber = 27,
    kMapFieldNumber = 28,
    kUserDefinedPointerFieldNumber = 31,
    kTypeParameterNameFieldNumber = 33,
    kIntegerParameterNameFieldNumber = 34,
    kIntegerLiteralFieldNumber = 35,
    kUnaryOpFieldNumber = 36,
    kBinaryOpFieldNumber = 37,
    kIfElseFieldNumber = 38,
    kReturnProgramFieldNumber = 39,
  };
  // .substrait.Type.Boolean bool = 1 [json_name = "bool"];
  bool has_bool_() const;
  private:
  bool _internal_has_bool_() const;
  public:
  void clear_bool_();
  const ::substrait::Type_Boolean& bool_() const;
  PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_();
  ::substrait::Type_Boolean* mutable_bool_();
  void set_allocated_bool_(::substrait::Type_Boolean* bool_);
  private:
  const ::substrait::Type_Boolean& _internal_bool_() const;
  ::substrait::Type_Boolean* _internal_mutable_bool_();
  public:
  void unsafe_arena_set_allocated_bool_(
      ::substrait::Type_Boolean* bool_);
  ::substrait::Type_Boolean* unsafe_arena_release_bool_();

  // .substrait.Type.I8 i8 = 2 [json_name = "i8"];
  bool has_i8() const;
  private:
  bool _internal_has_i8() const;
  public:
  void clear_i8();
  const ::substrait::Type_I8& i8() const;
  PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8();
  ::substrait::Type_I8* mutable_i8();
  void set_allocated_i8(::substrait::Type_I8* i8);
  private:
  const ::substrait::Type_I8& _internal_i8() const;
  ::substrait::Type_I8* _internal_mutable_i8();
  public:
  void unsafe_arena_set_allocated_i8(
      ::substrait::Type_I8* i8);
  ::substrait::Type_I8* unsafe_arena_release_i8();

  // .substrait.Type.I16 i16 = 3 [json_name = "i16"];
  bool has_i16() const;
  private:
  bool _internal_has_i16() const;
  public:
  void clear_i16();
  const ::substrait::Type_I16& i16() const;
  PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16();
  ::substrait::Type_I16* mutable_i16();
  void set_allocated_i16(::substrait::Type_I16* i16);
  private:
  const ::substrait::Type_I16& _internal_i16() const;
  ::substrait::Type_I16* _internal_mutable_i16();
  public:
  void unsafe_arena_set_allocated_i16(
      ::substrait::Type_I16* i16);
  ::substrait::Type_I16* unsafe_arena_release_i16();

  // .substrait.Type.I32 i32 = 5 [json_name = "i32"];
  bool has_i32() const;
  private:
  bool _internal_has_i32() const;
  public:
  void clear_i32();
  const ::substrait::Type_I32& i32() const;
  PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32();
  ::substrait::Type_I32* mutable_i32();
  void set_allocated_i32(::substrait::Type_I32* i32);
  private:
  const ::substrait::Type_I32& _internal_i32() const;
  ::substrait::Type_I32* _internal_mutable_i32();
  public:
  void unsafe_arena_set_allocated_i32(
      ::substrait::Type_I32* i32);
  ::substrait::Type_I32* unsafe_arena_release_i32();

  // .substrait.Type.I64 i64 = 7 [json_name = "i64"];
  bool has_i64() const;
  private:
  bool _internal_has_i64() const;
  public:
  void clear_i64();
  const ::substrait::Type_I64& i64() const;
  PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64();
  ::substrait::Type_I64* mutable_i64();
  void set_allocated_i64(::substrait::Type_I64* i64);
  private:
  const ::substrait::Type_I64& _internal_i64() const;
  ::substrait::Type_I64* _internal_mutable_i64();
  public:
  void unsafe_arena_set_allocated_i64(
      ::substrait::Type_I64* i64);
  ::substrait::Type_I64* unsafe_arena_release_i64();

  // .substrait.Type.FP32 fp32 = 10 [json_name = "fp32"];
  bool has_fp32() const;
  private:
  bool _internal_has_fp32() const;
  public:
  void clear_fp32();
  const ::substrait::Type_FP32& fp32() const;
  PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32();
  ::substrait::Type_FP32* mutable_fp32();
  void set_allocated_fp32(::substrait::Type_FP32* fp32);
  private:
  const ::substrait::Type_FP32& _internal_fp32() const;
  ::substrait::Type_FP32* _internal_mutable_fp32();
  public:
  void unsafe_arena_set_allocated_fp32(
      ::substrait::Type_FP32* fp32);
  ::substrait::Type_FP32* unsafe_arena_release_fp32();

  // .substrait.Type.FP64 fp64 = 11 [json_name = "fp64"];
  bool has_fp64() const;
  private:
  bool _internal_has_fp64() const;
  public:
  void clear_fp64();
  const ::substrait::Type_FP64& fp64() const;
  PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64();
  ::substrait::Type_FP64* mutable_fp64();
  void set_allocated_fp64(::substrait::Type_FP64* fp64);
  private:
  const ::substrait::Type_FP64& _internal_fp64() const;
  ::substrait::Type_FP64* _internal_mutable_fp64();
  public:
  void unsafe_arena_set_allocated_fp64(
      ::substrait::Type_FP64* fp64);
  ::substrait::Type_FP64* unsafe_arena_release_fp64();

  // .substrait.Type.String string = 12 [json_name = "string"];
  bool has_string() const;
  private:
  bool _internal_has_string() const;
  public:
  void clear_string();
  const ::substrait::Type_String& string() const;
  PROTOBUF_NODISCARD ::substrait::Type_String* release_string();
  ::substrait::Type_String* mutable_string();
  void set_allocated_string(::substrait::Type_String* string);
  private:
  const ::substrait::Type_String& _internal_string() const;
  ::substrait::Type_String* _internal_mutable_string();
  public:
  void unsafe_arena_set_allocated_string(
      ::substrait::Type_String* string);
  ::substrait::Type_String* unsafe_arena_release_string();

  // .substrait.Type.Binary binary = 13 [json_name = "binary"];
  bool has_binary() const;
  private:
  bool _internal_has_binary() const;
  public:
  void clear_binary();
  const ::substrait::Type_Binary& binary() const;
  PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary();
  ::substrait::Type_Binary* mutable_binary();
  void set_allocated_binary(::substrait::Type_Binary* binary);
  private:
  const ::substrait::Type_Binary& _internal_binary() const;
  ::substrait::Type_Binary* _internal_mutable_binary();
  public:
  void unsafe_arena_set_allocated_binary(
      ::substrait::Type_Binary* binary);
  ::substrait::Type_Binary* unsafe_arena_release_binary();

  // .substrait.Type.Timestamp timestamp = 14 [json_name = "timestamp"];
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  const ::substrait::Type_Timestamp& timestamp() const;
  PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp();
  ::substrait::Type_Timestamp* mutable_timestamp();
  void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp);
  private:
  const ::substrait::Type_Timestamp& _internal_timestamp() const;
  ::substrait::Type_Timestamp* _internal_mutable_timestamp();
  public:
  void unsafe_arena_set_allocated_timestamp(
      ::substrait::Type_Timestamp* timestamp);
  ::substrait::Type_Timestamp* unsafe_arena_release_timestamp();

  // .substrait.Type.Date date = 16 [json_name = "date"];
  bool has_date() const;
  private:
  bool _internal_has_date() const;
  public:
  void clear_date();
  const ::substrait::Type_Date& date() const;
  PROTOBUF_NODISCARD ::substrait::Type_Date* release_date();
  ::substrait::Type_Date* mutable_date();
  void set_allocated_date(::substrait::Type_Date* date);
  private:
  const ::substrait::Type_Date& _internal_date() const;
  ::substrait::Type_Date* _internal_mutable_date();
  public:
  void unsafe_arena_set_allocated_date(
      ::substrait::Type_Date* date);
  ::substrait::Type_Date* unsafe_arena_release_date();

  // .substrait.Type.Time time = 17 [json_name = "time"];
  bool has_time() const;
  private:
  bool _internal_has_time() const;
  public:
  void clear_time();
  const ::substrait::Type_Time& time() const;
  PROTOBUF_NODISCARD ::substrait::Type_Time* release_time();
  ::substrait::Type_Time* mutable_time();
  void set_allocated_time(::substrait::Type_Time* time);
  private:
  const ::substrait::Type_Time& _internal_time() const;
  ::substrait::Type_Time* _internal_mutable_time();
  public:
  void unsafe_arena_set_allocated_time(
      ::substrait::Type_Time* time);
  ::substrait::Type_Time* unsafe_arena_release_time();

  // .substrait.Type.IntervalYear interval_year = 19 [json_name = "intervalYear"];
  bool has_interval_year() const;
  private:
  bool _internal_has_interval_year() const;
  public:
  void clear_interval_year();
  const ::substrait::Type_IntervalYear& interval_year() const;
  PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year();
  ::substrait::Type_IntervalYear* mutable_interval_year();
  void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year);
  private:
  const ::substrait::Type_IntervalYear& _internal_interval_year() const;
  ::substrait::Type_IntervalYear* _internal_mutable_interval_year();
  public:
  void unsafe_arena_set_allocated_interval_year(
      ::substrait::Type_IntervalYear* interval_year);
  ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year();

  // .substrait.Type.IntervalDay interval_day = 20 [json_name = "intervalDay"];
  bool has_interval_day() const;
  private:
  bool _internal_has_interval_day() const;
  public:
  void clear_interval_day();
  const ::substrait::Type_IntervalDay& interval_day() const;
  PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day();
  ::substrait::Type_IntervalDay* mutable_interval_day();
  void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day);
  private:
  const ::substrait::Type_IntervalDay& _internal_interval_day() const;
  ::substrait::Type_IntervalDay* _internal_mutable_interval_day();
  public:
  void unsafe_arena_set_allocated_interval_day(
      ::substrait::Type_IntervalDay* interval_day);
  ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day();

  // .substrait.Type.TimestampTZ timestamp_tz = 29 [json_name = "timestampTz"];
  bool has_timestamp_tz() const;
  private:
  bool _internal_has_timestamp_tz() const;
  public:
  void clear_timestamp_tz();
  const ::substrait::Type_TimestampTZ& timestamp_tz() const;
  PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz();
  ::substrait::Type_TimestampTZ* mutable_timestamp_tz();
  void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz);
  private:
  const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const;
  ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz();
  public:
  void unsafe_arena_set_allocated_timestamp_tz(
      ::substrait::Type_TimestampTZ* timestamp_tz);
  ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz();

  // .substrait.Type.UUID uuid = 32 [json_name = "uuid"];
  bool has_uuid() const;
  private:
  bool _internal_has_uuid() const;
  public:
  void clear_uuid();
  const ::substrait::Type_UUID& uuid() const;
  PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid();
  ::substrait::Type_UUID* mutable_uuid();
  void set_allocated_uuid(::substrait::Type_UUID* uuid);
  private:
  const ::substrait::Type_UUID& _internal_uuid() const;
  ::substrait::Type_UUID* _internal_mutable_uuid();
  public:
  void unsafe_arena_set_allocated_uuid(
      ::substrait::Type_UUID* uuid);
  ::substrait::Type_UUID* unsafe_arena_release_uuid();

  // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21 [json_name = "fixedChar"];
  bool has_fixed_char() const;
  private:
  bool _internal_has_fixed_char() const;
  public:
  void clear_fixed_char();
  const ::substrait::DerivationExpression_ExpressionFixedChar& fixed_char() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionFixedChar* release_fixed_char();
  ::substrait::DerivationExpression_ExpressionFixedChar* mutable_fixed_char();
  void set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char);
  private:
  const ::substrait::DerivationExpression_ExpressionFixedChar& _internal_fixed_char() const;
  ::substrait::DerivationExpression_ExpressionFixedChar* _internal_mutable_fixed_char();
  public:
  void unsafe_arena_set_allocated_fixed_char(
      ::substrait::DerivationExpression_ExpressionFixedChar* fixed_char);
  ::substrait::DerivationExpression_ExpressionFixedChar* unsafe_arena_release_fixed_char();

  // .substrait.DerivationExpression.ExpressionVarChar varchar = 22 [json_name = "varchar"];
  bool has_varchar() const;
  private:
  bool _internal_has_varchar() const;
  public:
  void clear_varchar();
  const ::substrait::DerivationExpression_ExpressionVarChar& varchar() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionVarChar* release_varchar();
  ::substrait::DerivationExpression_ExpressionVarChar* mutable_varchar();
  void set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar);
  private:
  const ::substrait::DerivationExpression_ExpressionVarChar& _internal_varchar() const;
  ::substrait::DerivationExpression_ExpressionVarChar* _internal_mutable_varchar();
  public:
  void unsafe_arena_set_allocated_varchar(
      ::substrait::DerivationExpression_ExpressionVarChar* varchar);
  ::substrait::DerivationExpression_ExpressionVarChar* unsafe_arena_release_varchar();

  // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23 [json_name = "fixedBinary"];
  bool has_fixed_binary() const;
  private:
  bool _internal_has_fixed_binary() const;
  public:
  void clear_fixed_binary();
  const ::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionFixedBinary* release_fixed_binary();
  ::substrait::DerivationExpression_ExpressionFixedBinary* mutable_fixed_binary();
  void set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary);
  private:
  const ::substrait::DerivationExpression_ExpressionFixedBinary& _internal_fixed_binary() const;
  ::substrait::DerivationExpression_ExpressionFixedBinary* _internal_mutable_fixed_binary();
  public:
  void unsafe_arena_set_allocated_fixed_binary(
      ::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary);
  ::substrait::DerivationExpression_ExpressionFixedBinary* unsafe_arena_release_fixed_binary();

  // .substrait.DerivationExpression.ExpressionDecimal decimal = 24 [json_name = "decimal"];
  bool has_decimal() const;
  private:
  bool _internal_has_decimal() const;
  public:
  void clear_decimal();
  const ::substrait::DerivationExpression_ExpressionDecimal& decimal() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionDecimal* release_decimal();
  ::substrait::DerivationExpression_ExpressionDecimal* mutable_decimal();
  void set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal);
  private:
  const ::substrait::DerivationExpression_ExpressionDecimal& _internal_decimal() const;
  ::substrait::DerivationExpression_ExpressionDecimal* _internal_mutable_decimal();
  public:
  void unsafe_arena_set_allocated_decimal(
      ::substrait::DerivationExpression_ExpressionDecimal* decimal);
  ::substrait::DerivationExpression_ExpressionDecimal* unsafe_arena_release_decimal();

  // .substrait.DerivationExpression.ExpressionStruct struct = 25 [json_name = "struct"];
  bool has_struct_() const;
  private:
  bool _internal_has_struct_() const;
  public:
  void clear_struct_();
  const ::substrait::DerivationExpression_ExpressionStruct& struct_() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionStruct* release_struct_();
  ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_();
  void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_);
  private:
  const ::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const;
  ::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_();
  public:
  void unsafe_arena_set_allocated_struct_(
      ::substrait::DerivationExpression_ExpressionStruct* struct_);
  ::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_();

  // .substrait.DerivationExpression.ExpressionList list = 27 [json_name = "list"];
  bool has_list() const;
  private:
  bool _internal_has_list() const;
  public:
  void clear_list();
  const ::substrait::DerivationExpression_ExpressionList& list() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionList* release_list();
  ::substrait::DerivationExpression_ExpressionList* mutable_list();
  void set_allocated_list(::substrait::DerivationExpression_ExpressionList* list);
  private:
  const ::substrait::DerivationExpression_ExpressionList& _internal_list() const;
  ::substrait::DerivationExpression_ExpressionList* _internal_mutable_list();
  public:
  void unsafe_arena_set_allocated_list(
      ::substrait::DerivationExpression_ExpressionList* list);
  ::substrait::DerivationExpression_ExpressionList* unsafe_arena_release_list();

  // .substrait.DerivationExpression.ExpressionMap map = 28 [json_name = "map"];
  bool has_map() const;
  private:
  bool _internal_has_map() const;
  public:
  void clear_map();
  const ::substrait::DerivationExpression_ExpressionMap& map() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionMap* release_map();
  ::substrait::DerivationExpression_ExpressionMap* mutable_map();
  void set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map);
  private:
  const ::substrait::DerivationExpression_ExpressionMap& _internal_map() const;
  ::substrait::DerivationExpression_ExpressionMap* _internal_mutable_map();
  public:
  void unsafe_arena_set_allocated_map(
      ::substrait::DerivationExpression_ExpressionMap* map);
  ::substrait::DerivationExpression_ExpressionMap* unsafe_arena_release_map();

  // uint32 user_defined_pointer = 31 [json_name = "userDefinedPointer"];
  bool has_user_defined_pointer() const;
  private:
  bool _internal_has_user_defined_pointer() const;
  public:
  void clear_user_defined_pointer();
  uint32_t user_defined_pointer() const;
  void set_user_defined_pointer(uint32_t value);
  private:
  uint32_t _internal_user_defined_pointer() const;
  void _internal_set_user_defined_pointer(uint32_t value);
  public:

  // string type_parameter_name = 33 [json_name = "typeParameterName"];
  bool has_type_parameter_name() const;
  private:
  bool _internal_has_type_parameter_name() const;
  public:
  void clear_type_parameter_name();
  const std::string& type_parameter_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type_parameter_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type_parameter_name();
  PROTOBUF_NODISCARD std::string* release_type_parameter_name();
  void set_allocated_type_parameter_name(std::string* type_parameter_name);
  private:
  const std::string& _internal_type_parameter_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_parameter_name(const std::string& value);
  std::string* _internal_mutable_type_parameter_name();
  public:

  // string integer_parameter_name = 34 [json_name = "integerParameterName"];
  bool has_integer_parameter_name() const;
  private:
  bool _internal_has_integer_parameter_name() const;
  public:
  void clear_integer_parameter_name();
  const std::string& integer_parameter_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_integer_parameter_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_integer_parameter_name();
  PROTOBUF_NODISCARD std::string* release_integer_parameter_name();
  void set_allocated_integer_parameter_name(std::string* integer_parameter_name);
  private:
  const std::string& _internal_integer_parameter_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_integer_parameter_name(const std::string& value);
  std::string* _internal_mutable_integer_parameter_name();
  public:

  // int32 integer_literal = 35 [json_name = "integerLiteral"];
  bool has_integer_literal() const;
  private:
  bool _internal_has_integer_literal() const;
  public:
  void clear_integer_literal();
  int32_t integer_literal() const;
  void set_integer_literal(int32_t value);
  private:
  int32_t _internal_integer_literal() const;
  void _internal_set_integer_literal(int32_t value);
  public:

  // .substrait.DerivationExpression.UnaryOp unary_op = 36 [json_name = "unaryOp"];
  bool has_unary_op() const;
  private:
  bool _internal_has_unary_op() const;
  public:
  void clear_unary_op();
  const ::substrait::DerivationExpression_UnaryOp& unary_op() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_UnaryOp* release_unary_op();
  ::substrait::DerivationExpression_UnaryOp* mutable_unary_op();
  void set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op);
  private:
  const ::substrait::DerivationExpression_UnaryOp& _internal_unary_op() const;
  ::substrait::DerivationExpression_UnaryOp* _internal_mutable_unary_op();
  public:
  void unsafe_arena_set_allocated_unary_op(
      ::substrait::DerivationExpression_UnaryOp* unary_op);
  ::substrait::DerivationExpression_UnaryOp* unsafe_arena_release_unary_op();

  // .substrait.DerivationExpression.BinaryOp binary_op = 37 [json_name = "binaryOp"];
  bool has_binary_op() const;
  private:
  bool _internal_has_binary_op() const;
  public:
  void clear_binary_op();
  const ::substrait::DerivationExpression_BinaryOp& binary_op() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_BinaryOp* release_binary_op();
  ::substrait::DerivationExpression_BinaryOp* mutable_binary_op();
  void set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op);
  private:
  const ::substrait::DerivationExpression_BinaryOp& _internal_binary_op() const;
  ::substrait::DerivationExpression_BinaryOp* _internal_mutable_binary_op();
  public:
  void unsafe_arena_set_allocated_binary_op(
      ::substrait::DerivationExpression_BinaryOp* binary_op);
  ::substrait::DerivationExpression_BinaryOp* unsafe_arena_release_binary_op();

  // .substrait.DerivationExpression.IfElse if_else = 38 [json_name = "ifElse"];
  bool has_if_else() const;
  private:
  bool _internal_has_if_else() const;
  public:
  void clear_if_else();
  const ::substrait::DerivationExpression_IfElse& if_else() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_IfElse* release_if_else();
  ::substrait::DerivationExpression_IfElse* mutable_if_else();
  void set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else);
  private:
  const ::substrait::DerivationExpression_IfElse& _internal_if_else() const;
  ::substrait::DerivationExpression_IfElse* _internal_mutable_if_else();
  public:
  void unsafe_arena_set_allocated_if_else(
      ::substrait::DerivationExpression_IfElse* if_else);
  ::substrait::DerivationExpression_IfElse* unsafe_arena_release_if_else();

  // .substrait.DerivationExpression.ReturnProgram return_program = 39 [json_name = "returnProgram"];
  bool has_return_program() const;
  private:
  bool _internal_has_return_program() const;
  public:
  void clear_return_program();
  const ::substrait::DerivationExpression_ReturnProgram& return_program() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ReturnProgram* release_return_program();
  ::substrait::DerivationExpression_ReturnProgram* mutable_return_program();
  void set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program);
  private:
  const ::substrait::DerivationExpression_ReturnProgram& _internal_return_program() const;
  ::substrait::DerivationExpression_ReturnProgram* _internal_mutable_return_program();
  public:
  void unsafe_arena_set_allocated_return_program(
      ::substrait::DerivationExpression_ReturnProgram* return_program);
  ::substrait::DerivationExpression_ReturnProgram* unsafe_arena_release_return_program();

  void clear_kind();
  KindCase kind_case() const;
  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression)
 private:
  class _Internal;
  void set_has_bool_();
  void set_has_i8();
  void set_has_i16();
  void set_has_i32();
  void set_has_i64();
  void set_has_fp32();
  void set_has_fp64();
  void set_has_string();
  void set_has_binary();
  void set_has_timestamp();
  void set_has_date();
  void set_has_time();
  void set_has_interval_year();
  void set_has_interval_day();
  void set_has_timestamp_tz();
  void set_has_uuid();
  void set_has_fixed_char();
  void set_has_varchar();
  void set_has_fixed_binary();
  void set_has_decimal();
  void set_has_struct_();
  void set_has_list();
  void set_has_map();
  void set_has_user_defined_pointer();
  void set_has_type_parameter_name();
  void set_has_integer_parameter_name();
  void set_has_integer_literal();
  void set_has_unary_op();
  void set_has_binary_op();
  void set_has_if_else();
  void set_has_return_program();

  inline bool has_kind() const;
  inline void clear_has_kind();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union KindUnion {
    constexpr KindUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::substrait::Type_Boolean* bool__;
    ::substrait::Type_I8* i8_;
    ::substrait::Type_I16* i16_;
    ::substrait::Type_I32* i32_;
    ::substrait::Type_I64* i64_;
    ::substrait::Type_FP32* fp32_;
    ::substrait::Type_FP64* fp64_;
    ::substrait::Type_String* string_;
    ::substrait::Type_Binary* binary_;
    ::substrait::Type_Timestamp* timestamp_;
    ::substrait::Type_Date* date_;
    ::substrait::Type_Time* time_;
    ::substrait::Type_IntervalYear* interval_year_;
    ::substrait::Type_IntervalDay* interval_day_;
    ::substrait::Type_TimestampTZ* timestamp_tz_;
    ::substrait::Type_UUID* uuid_;
    ::substrait::DerivationExpression_ExpressionFixedChar* fixed_char_;
    ::substrait::DerivationExpression_ExpressionVarChar* varchar_;
    ::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary_;
    ::substrait::DerivationExpression_ExpressionDecimal* decimal_;
    ::substrait::DerivationExpression_ExpressionStruct* struct__;
    ::substrait::DerivationExpression_ExpressionList* list_;
    ::substrait::DerivationExpression_ExpressionMap* map_;
    uint32_t user_defined_pointer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_parameter_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr integer_parameter_name_;
    int32_t integer_literal_;
    ::substrait::DerivationExpression_UnaryOp* unary_op_;
    ::substrait::DerivationExpression_BinaryOp* binary_op_;
    ::substrait::DerivationExpression_IfElse* if_else_;
    ::substrait::DerivationExpression_ReturnProgram* return_program_;
  } kind_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// DerivationExpression_ExpressionFixedChar

// .substrait.DerivationExpression length = 1 [json_name = "length"];
inline bool DerivationExpression_ExpressionFixedChar::_internal_has_length() const {
  return this != internal_default_instance() && length_ != nullptr;
}
inline bool DerivationExpression_ExpressionFixedChar::has_length() const {
  return _internal_has_length();
}
inline void DerivationExpression_ExpressionFixedChar::clear_length() {
  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
    delete length_;
  }
  length_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::_internal_length() const {
  const ::substrait::DerivationExpression* p = length_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::length() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.length)
  return _internal_length();
}
inline void DerivationExpression_ExpressionFixedChar::unsafe_arena_set_allocated_length(
    ::substrait::DerivationExpression* length) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_);
  }
  length_ = length;
  if (length) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionFixedChar.length)
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::release_length() {
  
  ::substrait::DerivationExpression* temp = length_;
  length_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::unsafe_arena_release_length() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionFixedChar.length)
  
  ::substrait::DerivationExpression* temp = length_;
  length_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::_internal_mutable_length() {
  
  if (length_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    length_ = p;
  }
  return length_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::mutable_length() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_length();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedChar.length)
  return _msg;
}
inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::substrait::DerivationExpression* length) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete length_;
  }
  if (length) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length);
    if (message_arena != submessage_arena) {
      length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, length, submessage_arena);
    }
    
  } else {
    
  }
  length_ = length;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionFixedChar.length)
}

// uint32 variation_pointer = 2 [json_name = "variationPointer"];
inline void DerivationExpression_ExpressionFixedChar::clear_variation_pointer() {
  variation_pointer_ = 0u;
}
inline uint32_t DerivationExpression_ExpressionFixedChar::_internal_variation_pointer() const {
  return variation_pointer_;
}
inline uint32_t DerivationExpression_ExpressionFixedChar::variation_pointer() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer)
  return _internal_variation_pointer();
}
inline void DerivationExpression_ExpressionFixedChar::_internal_set_variation_pointer(uint32_t value) {
  
  variation_pointer_ = value;
}
inline void DerivationExpression_ExpressionFixedChar::set_variation_pointer(uint32_t value) {
  _internal_set_variation_pointer(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer)
}

// .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
inline void DerivationExpression_ExpressionFixedChar::clear_nullability() {
  nullability_ = 0;
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::_internal_nullability() const {
  return static_cast< ::substrait::Type_Nullability >(nullability_);
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::nullability() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.nullability)
  return _internal_nullability();
}
inline void DerivationExpression_ExpressionFixedChar::_internal_set_nullability(::substrait::Type_Nullability value) {
  
  nullability_ = value;
}
inline void DerivationExpression_ExpressionFixedChar::set_nullability(::substrait::Type_Nullability value) {
  _internal_set_nullability(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedChar.nullability)
}

// -------------------------------------------------------------------

// DerivationExpression_ExpressionVarChar

// .substrait.DerivationExpression length = 1 [json_name = "length"];
inline bool DerivationExpression_ExpressionVarChar::_internal_has_length() const {
  return this != internal_default_instance() && length_ != nullptr;
}
inline bool DerivationExpression_ExpressionVarChar::has_length() const {
  return _internal_has_length();
}
inline void DerivationExpression_ExpressionVarChar::clear_length() {
  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
    delete length_;
  }
  length_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::_internal_length() const {
  const ::substrait::DerivationExpression* p = length_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::length() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.length)
  return _internal_length();
}
inline void DerivationExpression_ExpressionVarChar::unsafe_arena_set_allocated_length(
    ::substrait::DerivationExpression* length) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_);
  }
  length_ = length;
  if (length) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionVarChar.length)
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::release_length() {
  
  ::substrait::DerivationExpression* temp = length_;
  length_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::unsafe_arena_release_length() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionVarChar.length)
  
  ::substrait::DerivationExpression* temp = length_;
  length_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::_internal_mutable_length() {
  
  if (length_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    length_ = p;
  }
  return length_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::mutable_length() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_length();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionVarChar.length)
  return _msg;
}
inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::substrait::DerivationExpression* length) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete length_;
  }
  if (length) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length);
    if (message_arena != submessage_arena) {
      length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, length, submessage_arena);
    }
    
  } else {
    
  }
  length_ = length;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionVarChar.length)
}

// uint32 variation_pointer = 2 [json_name = "variationPointer"];
inline void DerivationExpression_ExpressionVarChar::clear_variation_pointer() {
  variation_pointer_ = 0u;
}
inline uint32_t DerivationExpression_ExpressionVarChar::_internal_variation_pointer() const {
  return variation_pointer_;
}
inline uint32_t DerivationExpression_ExpressionVarChar::variation_pointer() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.variation_pointer)
  return _internal_variation_pointer();
}
inline void DerivationExpression_ExpressionVarChar::_internal_set_variation_pointer(uint32_t value) {
  
  variation_pointer_ = value;
}
inline void DerivationExpression_ExpressionVarChar::set_variation_pointer(uint32_t value) {
  _internal_set_variation_pointer(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionVarChar.variation_pointer)
}

// .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
inline void DerivationExpression_ExpressionVarChar::clear_nullability() {
  nullability_ = 0;
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::_internal_nullability() const {
  return static_cast< ::substrait::Type_Nullability >(nullability_);
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::nullability() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.nullability)
  return _internal_nullability();
}
inline void DerivationExpression_ExpressionVarChar::_internal_set_nullability(::substrait::Type_Nullability value) {
  
  nullability_ = value;
}
inline void DerivationExpression_ExpressionVarChar::set_nullability(::substrait::Type_Nullability value) {
  _internal_set_nullability(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionVarChar.nullability)
}

// -------------------------------------------------------------------

// DerivationExpression_ExpressionFixedBinary

// .substrait.DerivationExpression length = 1 [json_name = "length"];
inline bool DerivationExpression_ExpressionFixedBinary::_internal_has_length() const {
  return this != internal_default_instance() && length_ != nullptr;
}
inline bool DerivationExpression_ExpressionFixedBinary::has_length() const {
  return _internal_has_length();
}
inline void DerivationExpression_ExpressionFixedBinary::clear_length() {
  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
    delete length_;
  }
  length_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::_internal_length() const {
  const ::substrait::DerivationExpression* p = length_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::length() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.length)
  return _internal_length();
}
inline void DerivationExpression_ExpressionFixedBinary::unsafe_arena_set_allocated_length(
    ::substrait::DerivationExpression* length) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_);
  }
  length_ = length;
  if (length) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionFixedBinary.length)
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::release_length() {
  
  ::substrait::DerivationExpression* temp = length_;
  length_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::unsafe_arena_release_length() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionFixedBinary.length)
  
  ::substrait::DerivationExpression* temp = length_;
  length_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::_internal_mutable_length() {
  
  if (length_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    length_ = p;
  }
  return length_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::mutable_length() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_length();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedBinary.length)
  return _msg;
}
inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::substrait::DerivationExpression* length) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete length_;
  }
  if (length) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length);
    if (message_arena != submessage_arena) {
      length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, length, submessage_arena);
    }
    
  } else {
    
  }
  length_ = length;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionFixedBinary.length)
}

// uint32 variation_pointer = 2 [json_name = "variationPointer"];
inline void DerivationExpression_ExpressionFixedBinary::clear_variation_pointer() {
  variation_pointer_ = 0u;
}
inline uint32_t DerivationExpression_ExpressionFixedBinary::_internal_variation_pointer() const {
  return variation_pointer_;
}
inline uint32_t DerivationExpression_ExpressionFixedBinary::variation_pointer() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer)
  return _internal_variation_pointer();
}
inline void DerivationExpression_ExpressionFixedBinary::_internal_set_variation_pointer(uint32_t value) {
  
  variation_pointer_ = value;
}
inline void DerivationExpression_ExpressionFixedBinary::set_variation_pointer(uint32_t value) {
  _internal_set_variation_pointer(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer)
}

// .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
inline void DerivationExpression_ExpressionFixedBinary::clear_nullability() {
  nullability_ = 0;
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::_internal_nullability() const {
  return static_cast< ::substrait::Type_Nullability >(nullability_);
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::nullability() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.nullability)
  return _internal_nullability();
}
inline void DerivationExpression_ExpressionFixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) {
  
  nullability_ = value;
}
inline void DerivationExpression_ExpressionFixedBinary::set_nullability(::substrait::Type_Nullability value) {
  _internal_set_nullability(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedBinary.nullability)
}

// -------------------------------------------------------------------

// DerivationExpression_ExpressionDecimal

// .substrait.DerivationExpression scale = 1 [json_name = "scale"];
inline bool DerivationExpression_ExpressionDecimal::_internal_has_scale() const {
  return this != internal_default_instance() && scale_ != nullptr;
}
inline bool DerivationExpression_ExpressionDecimal::has_scale() const {
  return _internal_has_scale();
}
inline void DerivationExpression_ExpressionDecimal::clear_scale() {
  if (GetArenaForAllocation() == nullptr && scale_ != nullptr) {
    delete scale_;
  }
  scale_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_scale() const {
  const ::substrait::DerivationExpression* p = scale_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::scale() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.scale)
  return _internal_scale();
}
inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_scale(
    ::substrait::DerivationExpression* scale) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_);
  }
  scale_ = scale;
  if (scale) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionDecimal.scale)
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_scale() {
  
  ::substrait::DerivationExpression* temp = scale_;
  scale_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_scale() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionDecimal.scale)
  
  ::substrait::DerivationExpression* temp = scale_;
  scale_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_scale() {
  
  if (scale_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    scale_ = p;
  }
  return scale_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_scale() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_scale();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.scale)
  return _msg;
}
inline void DerivationExpression_ExpressionDecimal::set_allocated_scale(::substrait::DerivationExpression* scale) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete scale_;
  }
  if (scale) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(scale);
    if (message_arena != submessage_arena) {
      scale = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scale, submessage_arena);
    }
    
  } else {
    
  }
  scale_ = scale;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionDecimal.scale)
}

// .substrait.DerivationExpression precision = 2 [json_name = "precision"];
inline bool DerivationExpression_ExpressionDecimal::_internal_has_precision() const {
  return this != internal_default_instance() && precision_ != nullptr;
}
inline bool DerivationExpression_ExpressionDecimal::has_precision() const {
  return _internal_has_precision();
}
inline void DerivationExpression_ExpressionDecimal::clear_precision() {
  if (GetArenaForAllocation() == nullptr && precision_ != nullptr) {
    delete precision_;
  }
  precision_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_precision() const {
  const ::substrait::DerivationExpression* p = precision_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::precision() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.precision)
  return _internal_precision();
}
inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_precision(
    ::substrait::DerivationExpression* precision) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_);
  }
  precision_ = precision;
  if (precision) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionDecimal.precision)
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_precision() {
  
  ::substrait::DerivationExpression* temp = precision_;
  precision_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_precision() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionDecimal.precision)
  
  ::substrait::DerivationExpression* temp = precision_;
  precision_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_precision() {
  
  if (precision_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    precision_ = p;
  }
  return precision_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_precision() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_precision();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.precision)
  return _msg;
}
inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::substrait::DerivationExpression* precision) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete precision_;
  }
  if (precision) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(precision);
    if (message_arena != submessage_arena) {
      precision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, precision, submessage_arena);
    }
    
  } else {
    
  }
  precision_ = precision;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionDecimal.precision)
}

// uint32 variation_pointer = 3 [json_name = "variationPointer"];
inline void DerivationExpression_ExpressionDecimal::clear_variation_pointer() {
  variation_pointer_ = 0u;
}
inline uint32_t DerivationExpression_ExpressionDecimal::_internal_variation_pointer() const {
  return variation_pointer_;
}
inline uint32_t DerivationExpression_ExpressionDecimal::variation_pointer() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.variation_pointer)
  return _internal_variation_pointer();
}
inline void DerivationExpression_ExpressionDecimal::_internal_set_variation_pointer(uint32_t value) {
  
  variation_pointer_ = value;
}
inline void DerivationExpression_ExpressionDecimal::set_variation_pointer(uint32_t value) {
  _internal_set_variation_pointer(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionDecimal.variation_pointer)
}

// .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
inline void DerivationExpression_ExpressionDecimal::clear_nullability() {
  nullability_ = 0;
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::_internal_nullability() const {
  return static_cast< ::substrait::Type_Nullability >(nullability_);
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::nullability() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.nullability)
  return _internal_nullability();
}
inline void DerivationExpression_ExpressionDecimal::_internal_set_nullability(::substrait::Type_Nullability value) {
  
  nullability_ = value;
}
inline void DerivationExpression_ExpressionDecimal::set_nullability(::substrait::Type_Nullability value) {
  _internal_set_nullability(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionDecimal.nullability)
}

// -------------------------------------------------------------------

// DerivationExpression_ExpressionStruct

// repeated .substrait.DerivationExpression types = 1 [json_name = "types"];
inline int DerivationExpression_ExpressionStruct::_internal_types_size() const {
  return types_.size();
}
inline int DerivationExpression_ExpressionStruct::types_size() const {
  return _internal_types_size();
}
inline void DerivationExpression_ExpressionStruct::clear_types() {
  types_.Clear();
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::mutable_types(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionStruct.types)
  return types_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >*
DerivationExpression_ExpressionStruct::mutable_types() {
  // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ExpressionStruct.types)
  return &types_;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::_internal_types(int index) const {
  return types_.Get(index);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::types(int index) const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.types)
  return _internal_types(index);
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::_internal_add_types() {
  return types_.Add();
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::add_types() {
  ::substrait::DerivationExpression* _add = _internal_add_types();
  // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionStruct.types)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >&
DerivationExpression_ExpressionStruct::types() const {
  // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ExpressionStruct.types)
  return types_;
}

// uint32 variation_pointer = 2 [json_name = "variationPointer"];
inline void DerivationExpression_ExpressionStruct::clear_variation_pointer() {
  variation_pointer_ = 0u;
}
inline uint32_t DerivationExpression_ExpressionStruct::_internal_variation_pointer() const {
  return variation_pointer_;
}
inline uint32_t DerivationExpression_ExpressionStruct::variation_pointer() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.variation_pointer)
  return _internal_variation_pointer();
}
inline void DerivationExpression_ExpressionStruct::_internal_set_variation_pointer(uint32_t value) {
  
  variation_pointer_ = value;
}
inline void DerivationExpression_ExpressionStruct::set_variation_pointer(uint32_t value) {
  _internal_set_variation_pointer(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionStruct.variation_pointer)
}

// .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
inline void DerivationExpression_ExpressionStruct::clear_nullability() {
  nullability_ = 0;
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionStruct::_internal_nullability() const {
  return static_cast< ::substrait::Type_Nullability >(nullability_);
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionStruct::nullability() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.nullability)
  return _internal_nullability();
}
inline void DerivationExpression_ExpressionStruct::_internal_set_nullability(::substrait::Type_Nullability value) {
  
  nullability_ = value;
}
inline void DerivationExpression_ExpressionStruct::set_nullability(::substrait::Type_Nullability value) {
  _internal_set_nullability(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionStruct.nullability)
}

// -------------------------------------------------------------------

// DerivationExpression_ExpressionNamedStruct

// repeated string names = 1 [json_name = "names"];
inline int DerivationExpression_ExpressionNamedStruct::_internal_names_size() const {
  return names_.size();
}
inline int DerivationExpression_ExpressionNamedStruct::names_size() const {
  return _internal_names_size();
}
inline void DerivationExpression_ExpressionNamedStruct::clear_names() {
  names_.Clear();
}
inline std::string* DerivationExpression_ExpressionNamedStruct::add_names() {
  std::string* _s = _internal_add_names();
  // @@protoc_insertion_point(field_add_mutable:substrait.DerivationExpression.ExpressionNamedStruct.names)
  return _s;
}
inline const std::string& DerivationExpression_ExpressionNamedStruct::_internal_names(int index) const {
  return names_.Get(index);
}
inline const std::string& DerivationExpression_ExpressionNamedStruct::names(int index) const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionNamedStruct.names)
  return _internal_names(index);
}
inline std::string* DerivationExpression_ExpressionNamedStruct::mutable_names(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionNamedStruct.names)
  return names_.Mutable(index);
}
inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const std::string& value) {
  names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names)
}
inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, std::string&& value) {
  names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names)
}
inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:substrait.DerivationExpression.ExpressionNamedStruct.names)
}
inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value, size_t size) {
  names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:substrait.DerivationExpression.ExpressionNamedStruct.names)
}
inline std::string* DerivationExpression_ExpressionNamedStruct::_internal_add_names() {
  return names_.Add();
}
inline void DerivationExpression_ExpressionNamedStruct::add_names(const std::string& value) {
  names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionNamedStruct.names)
}
inline void DerivationExpression_ExpressionNamedStruct::add_names(std::string&& value) {
  names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionNamedStruct.names)
}
inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:substrait.DerivationExpression.ExpressionNamedStruct.names)
}
inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value, size_t size) {
  names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:substrait.DerivationExpression.ExpressionNamedStruct.names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DerivationExpression_ExpressionNamedStruct::names() const {
  // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ExpressionNamedStruct.names)
  return names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DerivationExpression_ExpressionNamedStruct::mutable_names() {
  // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ExpressionNamedStruct.names)
  return &names_;
}

// .substrait.DerivationExpression.ExpressionStruct struct = 2 [json_name = "struct"];
inline bool DerivationExpression_ExpressionNamedStruct::_internal_has_struct_() const {
  return this != internal_default_instance() && struct__ != nullptr;
}
inline bool DerivationExpression_ExpressionNamedStruct::has_struct_() const {
  return _internal_has_struct_();
}
inline void DerivationExpression_ExpressionNamedStruct::clear_struct_() {
  if (GetArenaForAllocation() == nullptr && struct__ != nullptr) {
    delete struct__;
  }
  struct__ = nullptr;
}
inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::_internal_struct_() const {
  const ::substrait::DerivationExpression_ExpressionStruct* p = struct__;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression_ExpressionStruct&>(
      ::substrait::_DerivationExpression_ExpressionStruct_default_instance_);
}
inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::struct_() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionNamedStruct.struct)
  return _internal_struct_();
}
inline void DerivationExpression_ExpressionNamedStruct::unsafe_arena_set_allocated_struct_(
    ::substrait::DerivationExpression_ExpressionStruct* struct_) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__);
  }
  struct__ = struct_;
  if (struct_) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionNamedStruct.struct)
}
inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::release_struct_() {
  
  ::substrait::DerivationExpression_ExpressionStruct* temp = struct__;
  struct__ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::unsafe_arena_release_struct_() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionNamedStruct.struct)
  
  ::substrait::DerivationExpression_ExpressionStruct* temp = struct__;
  struct__ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::_internal_mutable_struct_() {
  
  if (struct__ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(GetArenaForAllocation());
    struct__ = p;
  }
  return struct__;
}
inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::mutable_struct_() {
  ::substrait::DerivationExpression_ExpressionStruct* _msg = _internal_mutable_struct_();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionNamedStruct.struct)
  return _msg;
}
inline void DerivationExpression_ExpressionNamedStruct::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete struct__;
  }
  if (struct_) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionStruct>::GetOwningArena(struct_);
    if (message_arena != submessage_arena) {
      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, struct_, submessage_arena);
    }
    
  } else {
    
  }
  struct__ = struct_;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionNamedStruct.struct)
}

// -------------------------------------------------------------------

// DerivationExpression_ExpressionList

// .substrait.DerivationExpression type = 1 [json_name = "type"];
inline bool DerivationExpression_ExpressionList::_internal_has_type() const {
  return this != internal_default_instance() && type_ != nullptr;
}
inline bool DerivationExpression_ExpressionList::has_type() const {
  return _internal_has_type();
}
inline void DerivationExpression_ExpressionList::clear_type() {
  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
    delete type_;
  }
  type_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::_internal_type() const {
  const ::substrait::DerivationExpression* p = type_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::type() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.type)
  return _internal_type();
}
inline void DerivationExpression_ExpressionList::unsafe_arena_set_allocated_type(
    ::substrait::DerivationExpression* type) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
  }
  type_ = type;
  if (type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionList.type)
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::release_type() {
  
  ::substrait::DerivationExpression* temp = type_;
  type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::unsafe_arena_release_type() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionList.type)
  
  ::substrait::DerivationExpression* temp = type_;
  type_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::_internal_mutable_type() {
  
  if (type_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    type_ = p;
  }
  return type_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::mutable_type() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionList.type)
  return _msg;
}
inline void DerivationExpression_ExpressionList::set_allocated_type(::substrait::DerivationExpression* type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete type_;
  }
  if (type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(type);
    if (message_arena != submessage_arena) {
      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type, submessage_arena);
    }
    
  } else {
    
  }
  type_ = type;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionList.type)
}

// uint32 variation_pointer = 2 [json_name = "variationPointer"];
inline void DerivationExpression_ExpressionList::clear_variation_pointer() {
  variation_pointer_ = 0u;
}
inline uint32_t DerivationExpression_ExpressionList::_internal_variation_pointer() const {
  return variation_pointer_;
}
inline uint32_t DerivationExpression_ExpressionList::variation_pointer() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.variation_pointer)
  return _internal_variation_pointer();
}
inline void DerivationExpression_ExpressionList::_internal_set_variation_pointer(uint32_t value) {
  
  variation_pointer_ = value;
}
inline void DerivationExpression_ExpressionList::set_variation_pointer(uint32_t value) {
  _internal_set_variation_pointer(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionList.variation_pointer)
}

// .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
inline void DerivationExpression_ExpressionList::clear_nullability() {
  nullability_ = 0;
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionList::_internal_nullability() const {
  return static_cast< ::substrait::Type_Nullability >(nullability_);
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionList::nullability() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.nullability)
  return _internal_nullability();
}
inline void DerivationExpression_ExpressionList::_internal_set_nullability(::substrait::Type_Nullability value) {
  
  nullability_ = value;
}
inline void DerivationExpression_ExpressionList::set_nullability(::substrait::Type_Nullability value) {
  _internal_set_nullability(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionList.nullability)
}

// -------------------------------------------------------------------

// DerivationExpression_ExpressionMap

// .substrait.DerivationExpression key = 1 [json_name = "key"];
inline bool DerivationExpression_ExpressionMap::_internal_has_key() const {
  return this != internal_default_instance() && key_ != nullptr;
}
inline bool DerivationExpression_ExpressionMap::has_key() const {
  return _internal_has_key();
}
inline void DerivationExpression_ExpressionMap::clear_key() {
  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
    delete key_;
  }
  key_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_key() const {
  const ::substrait::DerivationExpression* p = key_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::key() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.key)
  return _internal_key();
}
inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_key(
    ::substrait::DerivationExpression* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_);
  }
  key_ = key;
  if (key) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionMap.key)
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_key() {
  
  ::substrait::DerivationExpression* temp = key_;
  key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionMap.key)
  
  ::substrait::DerivationExpression* temp = key_;
  key_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_key() {
  
  if (key_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    key_ = p;
  }
  return key_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_key() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.key)
  return _msg;
}
inline void DerivationExpression_ExpressionMap::set_allocated_key(::substrait::DerivationExpression* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    
  } else {
    
  }
  key_ = key;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionMap.key)
}

// .substrait.DerivationExpression value = 2 [json_name = "value"];
inline bool DerivationExpression_ExpressionMap::_internal_has_value() const {
  return this != internal_default_instance() && value_ != nullptr;
}
inline bool DerivationExpression_ExpressionMap::has_value() const {
  return _internal_has_value();
}
inline void DerivationExpression_ExpressionMap::clear_value() {
  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
    delete value_;
  }
  value_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_value() const {
  const ::substrait::DerivationExpression* p = value_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::value() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.value)
  return _internal_value();
}
inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_value(
    ::substrait::DerivationExpression* value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
  }
  value_ = value;
  if (value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionMap.value)
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_value() {
  
  ::substrait::DerivationExpression* temp = value_;
  value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionMap.value)
  
  ::substrait::DerivationExpression* temp = value_;
  value_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_value() {
  
  if (value_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    value_ = p;
  }
  return value_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_value() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.value)
  return _msg;
}
inline void DerivationExpression_ExpressionMap::set_allocated_value(::substrait::DerivationExpression* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete value_;
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(value);
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    
  } else {
    
  }
  value_ = value;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionMap.value)
}

// uint32 variation_pointer = 3 [json_name = "variationPointer"];
inline void DerivationExpression_ExpressionMap::clear_variation_pointer() {
  variation_pointer_ = 0u;
}
inline uint32_t DerivationExpression_ExpressionMap::_internal_variation_pointer() const {
  return variation_pointer_;
}
inline uint32_t DerivationExpression_ExpressionMap::variation_pointer() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.variation_pointer)
  return _internal_variation_pointer();
}
inline void DerivationExpression_ExpressionMap::_internal_set_variation_pointer(uint32_t value) {
  
  variation_pointer_ = value;
}
inline void DerivationExpression_ExpressionMap::set_variation_pointer(uint32_t value) {
  _internal_set_variation_pointer(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionMap.variation_pointer)
}

// .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
inline void DerivationExpression_ExpressionMap::clear_nullability() {
  nullability_ = 0;
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionMap::_internal_nullability() const {
  return static_cast< ::substrait::Type_Nullability >(nullability_);
}
inline ::substrait::Type_Nullability DerivationExpression_ExpressionMap::nullability() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.nullability)
  return _internal_nullability();
}
inline void DerivationExpression_ExpressionMap::_internal_set_nullability(::substrait::Type_Nullability value) {
  
  nullability_ = value;
}
inline void DerivationExpression_ExpressionMap::set_nullability(::substrait::Type_Nullability value) {
  _internal_set_nullability(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionMap.nullability)
}

// -------------------------------------------------------------------

// DerivationExpression_IfElse

// .substrait.DerivationExpression if_condition = 1 [json_name = "ifCondition"];
inline bool DerivationExpression_IfElse::_internal_has_if_condition() const {
  return this != internal_default_instance() && if_condition_ != nullptr;
}
inline bool DerivationExpression_IfElse::has_if_condition() const {
  return _internal_has_if_condition();
}
inline void DerivationExpression_IfElse::clear_if_condition() {
  if (GetArenaForAllocation() == nullptr && if_condition_ != nullptr) {
    delete if_condition_;
  }
  if_condition_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_condition() const {
  const ::substrait::DerivationExpression* p = if_condition_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_condition() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.if_condition)
  return _internal_if_condition();
}
inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_condition(
    ::substrait::DerivationExpression* if_condition) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_condition_);
  }
  if_condition_ = if_condition;
  if (if_condition) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.if_condition)
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_condition() {
  
  ::substrait::DerivationExpression* temp = if_condition_;
  if_condition_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_condition() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.if_condition)
  
  ::substrait::DerivationExpression* temp = if_condition_;
  if_condition_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_condition() {
  
  if (if_condition_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    if_condition_ = p;
  }
  return if_condition_;
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_condition() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_if_condition();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_condition)
  return _msg;
}
inline void DerivationExpression_IfElse::set_allocated_if_condition(::substrait::DerivationExpression* if_condition) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete if_condition_;
  }
  if (if_condition) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(if_condition);
    if (message_arena != submessage_arena) {
      if_condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, if_condition, submessage_arena);
    }
    
  } else {
    
  }
  if_condition_ = if_condition;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.if_condition)
}

// .substrait.DerivationExpression if_return = 2 [json_name = "ifReturn"];
inline bool DerivationExpression_IfElse::_internal_has_if_return() const {
  return this != internal_default_instance() && if_return_ != nullptr;
}
inline bool DerivationExpression_IfElse::has_if_return() const {
  return _internal_has_if_return();
}
inline void DerivationExpression_IfElse::clear_if_return() {
  if (GetArenaForAllocation() == nullptr && if_return_ != nullptr) {
    delete if_return_;
  }
  if_return_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_return() const {
  const ::substrait::DerivationExpression* p = if_return_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_return() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.if_return)
  return _internal_if_return();
}
inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_return(
    ::substrait::DerivationExpression* if_return) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_return_);
  }
  if_return_ = if_return;
  if (if_return) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.if_return)
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_return() {
  
  ::substrait::DerivationExpression* temp = if_return_;
  if_return_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_return() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.if_return)
  
  ::substrait::DerivationExpression* temp = if_return_;
  if_return_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_return() {
  
  if (if_return_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    if_return_ = p;
  }
  return if_return_;
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_return() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_if_return();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_return)
  return _msg;
}
inline void DerivationExpression_IfElse::set_allocated_if_return(::substrait::DerivationExpression* if_return) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete if_return_;
  }
  if (if_return) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(if_return);
    if (message_arena != submessage_arena) {
      if_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, if_return, submessage_arena);
    }
    
  } else {
    
  }
  if_return_ = if_return;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.if_return)
}

// .substrait.DerivationExpression else_return = 3 [json_name = "elseReturn"];
inline bool DerivationExpression_IfElse::_internal_has_else_return() const {
  return this != internal_default_instance() && else_return_ != nullptr;
}
inline bool DerivationExpression_IfElse::has_else_return() const {
  return _internal_has_else_return();
}
inline void DerivationExpression_IfElse::clear_else_return() {
  if (GetArenaForAllocation() == nullptr && else_return_ != nullptr) {
    delete else_return_;
  }
  else_return_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_else_return() const {
  const ::substrait::DerivationExpression* p = else_return_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::else_return() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.else_return)
  return _internal_else_return();
}
inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_else_return(
    ::substrait::DerivationExpression* else_return) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else_return_);
  }
  else_return_ = else_return;
  if (else_return) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.else_return)
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_else_return() {
  
  ::substrait::DerivationExpression* temp = else_return_;
  else_return_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_else_return() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.else_return)
  
  ::substrait::DerivationExpression* temp = else_return_;
  else_return_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_else_return() {
  
  if (else_return_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    else_return_ = p;
  }
  return else_return_;
}
inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_else_return() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_else_return();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.else_return)
  return _msg;
}
inline void DerivationExpression_IfElse::set_allocated_else_return(::substrait::DerivationExpression* else_return) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete else_return_;
  }
  if (else_return) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(else_return);
    if (message_arena != submessage_arena) {
      else_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, else_return, submessage_arena);
    }
    
  } else {
    
  }
  else_return_ = else_return;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.else_return)
}

// -------------------------------------------------------------------

// DerivationExpression_UnaryOp

// .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1 [json_name = "opType"];
inline void DerivationExpression_UnaryOp::clear_op_type() {
  op_type_ = 0;
}
inline ::substrait::DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::_internal_op_type() const {
  return static_cast< ::substrait::DerivationExpression_UnaryOp_UnaryOpType >(op_type_);
}
inline ::substrait::DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::op_type() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.UnaryOp.op_type)
  return _internal_op_type();
}
inline void DerivationExpression_UnaryOp::_internal_set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value) {
  
  op_type_ = value;
}
inline void DerivationExpression_UnaryOp::set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value) {
  _internal_set_op_type(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.UnaryOp.op_type)
}

// .substrait.DerivationExpression arg = 2 [json_name = "arg"];
inline bool DerivationExpression_UnaryOp::_internal_has_arg() const {
  return this != internal_default_instance() && arg_ != nullptr;
}
inline bool DerivationExpression_UnaryOp::has_arg() const {
  return _internal_has_arg();
}
inline void DerivationExpression_UnaryOp::clear_arg() {
  if (GetArenaForAllocation() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::_internal_arg() const {
  const ::substrait::DerivationExpression* p = arg_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::arg() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.UnaryOp.arg)
  return _internal_arg();
}
inline void DerivationExpression_UnaryOp::unsafe_arena_set_allocated_arg(
    ::substrait::DerivationExpression* arg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
  }
  arg_ = arg;
  if (arg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.UnaryOp.arg)
}
inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::release_arg() {
  
  ::substrait::DerivationExpression* temp = arg_;
  arg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::unsafe_arena_release_arg() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.UnaryOp.arg)
  
  ::substrait::DerivationExpression* temp = arg_;
  arg_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::_internal_mutable_arg() {
  
  if (arg_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    arg_ = p;
  }
  return arg_;
}
inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::mutable_arg() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_arg();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.UnaryOp.arg)
  return _msg;
}
inline void DerivationExpression_UnaryOp::set_allocated_arg(::substrait::DerivationExpression* arg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete arg_;
  }
  if (arg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg);
    if (message_arena != submessage_arena) {
      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg, submessage_arena);
    }
    
  } else {
    
  }
  arg_ = arg;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.UnaryOp.arg)
}

// -------------------------------------------------------------------

// DerivationExpression_BinaryOp

// .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1 [json_name = "opType"];
inline void DerivationExpression_BinaryOp::clear_op_type() {
  op_type_ = 0;
}
inline ::substrait::DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::_internal_op_type() const {
  return static_cast< ::substrait::DerivationExpression_BinaryOp_BinaryOpType >(op_type_);
}
inline ::substrait::DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::op_type() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.op_type)
  return _internal_op_type();
}
inline void DerivationExpression_BinaryOp::_internal_set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value) {
  
  op_type_ = value;
}
inline void DerivationExpression_BinaryOp::set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value) {
  _internal_set_op_type(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.BinaryOp.op_type)
}

// .substrait.DerivationExpression arg1 = 2 [json_name = "arg1"];
inline bool DerivationExpression_BinaryOp::_internal_has_arg1() const {
  return this != internal_default_instance() && arg1_ != nullptr;
}
inline bool DerivationExpression_BinaryOp::has_arg1() const {
  return _internal_has_arg1();
}
inline void DerivationExpression_BinaryOp::clear_arg1() {
  if (GetArenaForAllocation() == nullptr && arg1_ != nullptr) {
    delete arg1_;
  }
  arg1_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg1() const {
  const ::substrait::DerivationExpression* p = arg1_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg1() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.arg1)
  return _internal_arg1();
}
inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg1(
    ::substrait::DerivationExpression* arg1) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg1_);
  }
  arg1_ = arg1;
  if (arg1) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.BinaryOp.arg1)
}
inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg1() {
  
  ::substrait::DerivationExpression* temp = arg1_;
  arg1_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg1() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.BinaryOp.arg1)
  
  ::substrait::DerivationExpression* temp = arg1_;
  arg1_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg1() {
  
  if (arg1_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    arg1_ = p;
  }
  return arg1_;
}
inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg1() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_arg1();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg1)
  return _msg;
}
inline void DerivationExpression_BinaryOp::set_allocated_arg1(::substrait::DerivationExpression* arg1) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete arg1_;
  }
  if (arg1) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg1);
    if (message_arena != submessage_arena) {
      arg1 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg1, submessage_arena);
    }
    
  } else {
    
  }
  arg1_ = arg1;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.BinaryOp.arg1)
}

// .substrait.DerivationExpression arg2 = 3 [json_name = "arg2"];
inline bool DerivationExpression_BinaryOp::_internal_has_arg2() const {
  return this != internal_default_instance() && arg2_ != nullptr;
}
inline bool DerivationExpression_BinaryOp::has_arg2() const {
  return _internal_has_arg2();
}
inline void DerivationExpression_BinaryOp::clear_arg2() {
  if (GetArenaForAllocation() == nullptr && arg2_ != nullptr) {
    delete arg2_;
  }
  arg2_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg2() const {
  const ::substrait::DerivationExpression* p = arg2_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg2() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.arg2)
  return _internal_arg2();
}
inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg2(
    ::substrait::DerivationExpression* arg2) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg2_);
  }
  arg2_ = arg2;
  if (arg2) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.BinaryOp.arg2)
}
inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg2() {
  
  ::substrait::DerivationExpression* temp = arg2_;
  arg2_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg2() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.BinaryOp.arg2)
  
  ::substrait::DerivationExpression* temp = arg2_;
  arg2_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg2() {
  
  if (arg2_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    arg2_ = p;
  }
  return arg2_;
}
inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg2() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_arg2();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg2)
  return _msg;
}
inline void DerivationExpression_BinaryOp::set_allocated_arg2(::substrait::DerivationExpression* arg2) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete arg2_;
  }
  if (arg2) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg2);
    if (message_arena != submessage_arena) {
      arg2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arg2, submessage_arena);
    }
    
  } else {
    
  }
  arg2_ = arg2;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.BinaryOp.arg2)
}

// -------------------------------------------------------------------

// DerivationExpression_ReturnProgram_Assignment

// string name = 1 [json_name = "name"];
inline void DerivationExpression_ReturnProgram_Assignment::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& DerivationExpression_ReturnProgram_Assignment::name() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.Assignment.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DerivationExpression_ReturnProgram_Assignment::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ReturnProgram.Assignment.name)
}
inline std::string* DerivationExpression_ReturnProgram_Assignment::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.name)
  return _s;
}
inline const std::string& DerivationExpression_ReturnProgram_Assignment::_internal_name() const {
  return name_.Get();
}
inline void DerivationExpression_ReturnProgram_Assignment::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DerivationExpression_ReturnProgram_Assignment::release_name() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.Assignment.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.name)
}

// .substrait.DerivationExpression expression = 2 [json_name = "expression"];
inline bool DerivationExpression_ReturnProgram_Assignment::_internal_has_expression() const {
  return this != internal_default_instance() && expression_ != nullptr;
}
inline bool DerivationExpression_ReturnProgram_Assignment::has_expression() const {
  return _internal_has_expression();
}
inline void DerivationExpression_ReturnProgram_Assignment::clear_expression() {
  if (GetArenaForAllocation() == nullptr && expression_ != nullptr) {
    delete expression_;
  }
  expression_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::_internal_expression() const {
  const ::substrait::DerivationExpression* p = expression_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::expression() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
  return _internal_expression();
}
inline void DerivationExpression_ReturnProgram_Assignment::unsafe_arena_set_allocated_expression(
    ::substrait::DerivationExpression* expression) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_);
  }
  expression_ = expression;
  if (expression) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
}
inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::release_expression() {
  
  ::substrait::DerivationExpression* temp = expression_;
  expression_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::unsafe_arena_release_expression() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
  
  ::substrait::DerivationExpression* temp = expression_;
  expression_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_expression() {
  
  if (expression_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    expression_ = p;
  }
  return expression_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::mutable_expression() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_expression();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
  return _msg;
}
inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_expression(::substrait::DerivationExpression* expression) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete expression_;
  }
  if (expression) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(expression);
    if (message_arena != submessage_arena) {
      expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expression, submessage_arena);
    }
    
  } else {
    
  }
  expression_ = expression;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
}

// -------------------------------------------------------------------

// DerivationExpression_ReturnProgram

// repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1 [json_name = "assignments"];
inline int DerivationExpression_ReturnProgram::_internal_assignments_size() const {
  return assignments_.size();
}
inline int DerivationExpression_ReturnProgram::assignments_size() const {
  return _internal_assignments_size();
}
inline void DerivationExpression_ReturnProgram::clear_assignments() {
  assignments_.Clear();
}
inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::mutable_assignments(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.assignments)
  return assignments_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >*
DerivationExpression_ReturnProgram::mutable_assignments() {
  // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ReturnProgram.assignments)
  return &assignments_;
}
inline const ::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::_internal_assignments(int index) const {
  return assignments_.Get(index);
}
inline const ::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::assignments(int index) const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.assignments)
  return _internal_assignments(index);
}
inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::_internal_add_assignments() {
  return assignments_.Add();
}
inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::add_assignments() {
  ::substrait::DerivationExpression_ReturnProgram_Assignment* _add = _internal_add_assignments();
  // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ReturnProgram.assignments)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >&
DerivationExpression_ReturnProgram::assignments() const {
  // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ReturnProgram.assignments)
  return assignments_;
}

// .substrait.DerivationExpression final_expression = 2 [json_name = "finalExpression"];
inline bool DerivationExpression_ReturnProgram::_internal_has_final_expression() const {
  return this != internal_default_instance() && final_expression_ != nullptr;
}
inline bool DerivationExpression_ReturnProgram::has_final_expression() const {
  return _internal_has_final_expression();
}
inline void DerivationExpression_ReturnProgram::clear_final_expression() {
  if (GetArenaForAllocation() == nullptr && final_expression_ != nullptr) {
    delete final_expression_;
  }
  final_expression_ = nullptr;
}
inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram::_internal_final_expression() const {
  const ::substrait::DerivationExpression* p = final_expression_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram::final_expression() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.final_expression)
  return _internal_final_expression();
}
inline void DerivationExpression_ReturnProgram::unsafe_arena_set_allocated_final_expression(
    ::substrait::DerivationExpression* final_expression) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(final_expression_);
  }
  final_expression_ = final_expression;
  if (final_expression) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ReturnProgram.final_expression)
}
inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::release_final_expression() {
  
  ::substrait::DerivationExpression* temp = final_expression_;
  final_expression_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::unsafe_arena_release_final_expression() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.final_expression)
  
  ::substrait::DerivationExpression* temp = final_expression_;
  final_expression_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::_internal_mutable_final_expression() {
  
  if (final_expression_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    final_expression_ = p;
  }
  return final_expression_;
}
inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::mutable_final_expression() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_final_expression();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.final_expression)
  return _msg;
}
inline void DerivationExpression_ReturnProgram::set_allocated_final_expression(::substrait::DerivationExpression* final_expression) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete final_expression_;
  }
  if (final_expression) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(final_expression);
    if (message_arena != submessage_arena) {
      final_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, final_expression, submessage_arena);
    }
    
  } else {
    
  }
  final_expression_ = final_expression;
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.final_expression)
}

// -------------------------------------------------------------------

// DerivationExpression

// .substrait.Type.Boolean bool = 1 [json_name = "bool"];
inline bool DerivationExpression::_internal_has_bool_() const {
  return kind_case() == kBool;
}
inline bool DerivationExpression::has_bool_() const {
  return _internal_has_bool_();
}
inline void DerivationExpression::set_has_bool_() {
  _oneof_case_[0] = kBool;
}
inline ::substrait::Type_Boolean* DerivationExpression::release_bool_() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.bool)
  if (_internal_has_bool_()) {
    clear_has_kind();
      ::substrait::Type_Boolean* temp = kind_.bool__;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.bool__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_Boolean& DerivationExpression::_internal_bool_() const {
  return _internal_has_bool_()
      ? *kind_.bool__
      : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_);
}
inline const ::substrait::Type_Boolean& DerivationExpression::bool_() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.bool)
  return _internal_bool_();
}
inline ::substrait::Type_Boolean* DerivationExpression::unsafe_arena_release_bool_() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.bool)
  if (_internal_has_bool_()) {
    clear_has_kind();
    ::substrait::Type_Boolean* temp = kind_.bool__;
    kind_.bool__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) {
  clear_kind();
  if (bool_) {
    set_has_bool_();
    kind_.bool__ = bool_;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.bool)
}
inline ::substrait::Type_Boolean* DerivationExpression::_internal_mutable_bool_() {
  if (!_internal_has_bool_()) {
    clear_kind();
    set_has_bool_();
    kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation());
  }
  return kind_.bool__;
}
inline ::substrait::Type_Boolean* DerivationExpression::mutable_bool_() {
  ::substrait::Type_Boolean* _msg = _internal_mutable_bool_();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.bool)
  return _msg;
}

// .substrait.Type.I8 i8 = 2 [json_name = "i8"];
inline bool DerivationExpression::_internal_has_i8() const {
  return kind_case() == kI8;
}
inline bool DerivationExpression::has_i8() const {
  return _internal_has_i8();
}
inline void DerivationExpression::set_has_i8() {
  _oneof_case_[0] = kI8;
}
inline ::substrait::Type_I8* DerivationExpression::release_i8() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i8)
  if (_internal_has_i8()) {
    clear_has_kind();
      ::substrait::Type_I8* temp = kind_.i8_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.i8_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_I8& DerivationExpression::_internal_i8() const {
  return _internal_has_i8()
      ? *kind_.i8_
      : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_);
}
inline const ::substrait::Type_I8& DerivationExpression::i8() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i8)
  return _internal_i8();
}
inline ::substrait::Type_I8* DerivationExpression::unsafe_arena_release_i8() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i8)
  if (_internal_has_i8()) {
    clear_has_kind();
    ::substrait::Type_I8* temp = kind_.i8_;
    kind_.i8_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) {
  clear_kind();
  if (i8) {
    set_has_i8();
    kind_.i8_ = i8;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i8)
}
inline ::substrait::Type_I8* DerivationExpression::_internal_mutable_i8() {
  if (!_internal_has_i8()) {
    clear_kind();
    set_has_i8();
    kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation());
  }
  return kind_.i8_;
}
inline ::substrait::Type_I8* DerivationExpression::mutable_i8() {
  ::substrait::Type_I8* _msg = _internal_mutable_i8();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i8)
  return _msg;
}

// .substrait.Type.I16 i16 = 3 [json_name = "i16"];
inline bool DerivationExpression::_internal_has_i16() const {
  return kind_case() == kI16;
}
inline bool DerivationExpression::has_i16() const {
  return _internal_has_i16();
}
inline void DerivationExpression::set_has_i16() {
  _oneof_case_[0] = kI16;
}
inline ::substrait::Type_I16* DerivationExpression::release_i16() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i16)
  if (_internal_has_i16()) {
    clear_has_kind();
      ::substrait::Type_I16* temp = kind_.i16_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.i16_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_I16& DerivationExpression::_internal_i16() const {
  return _internal_has_i16()
      ? *kind_.i16_
      : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_);
}
inline const ::substrait::Type_I16& DerivationExpression::i16() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i16)
  return _internal_i16();
}
inline ::substrait::Type_I16* DerivationExpression::unsafe_arena_release_i16() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i16)
  if (_internal_has_i16()) {
    clear_has_kind();
    ::substrait::Type_I16* temp = kind_.i16_;
    kind_.i16_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) {
  clear_kind();
  if (i16) {
    set_has_i16();
    kind_.i16_ = i16;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i16)
}
inline ::substrait::Type_I16* DerivationExpression::_internal_mutable_i16() {
  if (!_internal_has_i16()) {
    clear_kind();
    set_has_i16();
    kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation());
  }
  return kind_.i16_;
}
inline ::substrait::Type_I16* DerivationExpression::mutable_i16() {
  ::substrait::Type_I16* _msg = _internal_mutable_i16();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i16)
  return _msg;
}

// .substrait.Type.I32 i32 = 5 [json_name = "i32"];
inline bool DerivationExpression::_internal_has_i32() const {
  return kind_case() == kI32;
}
inline bool DerivationExpression::has_i32() const {
  return _internal_has_i32();
}
inline void DerivationExpression::set_has_i32() {
  _oneof_case_[0] = kI32;
}
inline ::substrait::Type_I32* DerivationExpression::release_i32() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i32)
  if (_internal_has_i32()) {
    clear_has_kind();
      ::substrait::Type_I32* temp = kind_.i32_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.i32_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_I32& DerivationExpression::_internal_i32() const {
  return _internal_has_i32()
      ? *kind_.i32_
      : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_);
}
inline const ::substrait::Type_I32& DerivationExpression::i32() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i32)
  return _internal_i32();
}
inline ::substrait::Type_I32* DerivationExpression::unsafe_arena_release_i32() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i32)
  if (_internal_has_i32()) {
    clear_has_kind();
    ::substrait::Type_I32* temp = kind_.i32_;
    kind_.i32_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) {
  clear_kind();
  if (i32) {
    set_has_i32();
    kind_.i32_ = i32;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i32)
}
inline ::substrait::Type_I32* DerivationExpression::_internal_mutable_i32() {
  if (!_internal_has_i32()) {
    clear_kind();
    set_has_i32();
    kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation());
  }
  return kind_.i32_;
}
inline ::substrait::Type_I32* DerivationExpression::mutable_i32() {
  ::substrait::Type_I32* _msg = _internal_mutable_i32();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i32)
  return _msg;
}

// .substrait.Type.I64 i64 = 7 [json_name = "i64"];
inline bool DerivationExpression::_internal_has_i64() const {
  return kind_case() == kI64;
}
inline bool DerivationExpression::has_i64() const {
  return _internal_has_i64();
}
inline void DerivationExpression::set_has_i64() {
  _oneof_case_[0] = kI64;
}
inline ::substrait::Type_I64* DerivationExpression::release_i64() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i64)
  if (_internal_has_i64()) {
    clear_has_kind();
      ::substrait::Type_I64* temp = kind_.i64_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.i64_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_I64& DerivationExpression::_internal_i64() const {
  return _internal_has_i64()
      ? *kind_.i64_
      : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_);
}
inline const ::substrait::Type_I64& DerivationExpression::i64() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i64)
  return _internal_i64();
}
inline ::substrait::Type_I64* DerivationExpression::unsafe_arena_release_i64() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i64)
  if (_internal_has_i64()) {
    clear_has_kind();
    ::substrait::Type_I64* temp = kind_.i64_;
    kind_.i64_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) {
  clear_kind();
  if (i64) {
    set_has_i64();
    kind_.i64_ = i64;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i64)
}
inline ::substrait::Type_I64* DerivationExpression::_internal_mutable_i64() {
  if (!_internal_has_i64()) {
    clear_kind();
    set_has_i64();
    kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation());
  }
  return kind_.i64_;
}
inline ::substrait::Type_I64* DerivationExpression::mutable_i64() {
  ::substrait::Type_I64* _msg = _internal_mutable_i64();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i64)
  return _msg;
}

// .substrait.Type.FP32 fp32 = 10 [json_name = "fp32"];
inline bool DerivationExpression::_internal_has_fp32() const {
  return kind_case() == kFp32;
}
inline bool DerivationExpression::has_fp32() const {
  return _internal_has_fp32();
}
inline void DerivationExpression::set_has_fp32() {
  _oneof_case_[0] = kFp32;
}
inline ::substrait::Type_FP32* DerivationExpression::release_fp32() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fp32)
  if (_internal_has_fp32()) {
    clear_has_kind();
      ::substrait::Type_FP32* temp = kind_.fp32_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.fp32_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_FP32& DerivationExpression::_internal_fp32() const {
  return _internal_has_fp32()
      ? *kind_.fp32_
      : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_);
}
inline const ::substrait::Type_FP32& DerivationExpression::fp32() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fp32)
  return _internal_fp32();
}
inline ::substrait::Type_FP32* DerivationExpression::unsafe_arena_release_fp32() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fp32)
  if (_internal_has_fp32()) {
    clear_has_kind();
    ::substrait::Type_FP32* temp = kind_.fp32_;
    kind_.fp32_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) {
  clear_kind();
  if (fp32) {
    set_has_fp32();
    kind_.fp32_ = fp32;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fp32)
}
inline ::substrait::Type_FP32* DerivationExpression::_internal_mutable_fp32() {
  if (!_internal_has_fp32()) {
    clear_kind();
    set_has_fp32();
    kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation());
  }
  return kind_.fp32_;
}
inline ::substrait::Type_FP32* DerivationExpression::mutable_fp32() {
  ::substrait::Type_FP32* _msg = _internal_mutable_fp32();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp32)
  return _msg;
}

// .substrait.Type.FP64 fp64 = 11 [json_name = "fp64"];
inline bool DerivationExpression::_internal_has_fp64() const {
  return kind_case() == kFp64;
}
inline bool DerivationExpression::has_fp64() const {
  return _internal_has_fp64();
}
inline void DerivationExpression::set_has_fp64() {
  _oneof_case_[0] = kFp64;
}
inline ::substrait::Type_FP64* DerivationExpression::release_fp64() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fp64)
  if (_internal_has_fp64()) {
    clear_has_kind();
      ::substrait::Type_FP64* temp = kind_.fp64_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.fp64_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_FP64& DerivationExpression::_internal_fp64() const {
  return _internal_has_fp64()
      ? *kind_.fp64_
      : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_);
}
inline const ::substrait::Type_FP64& DerivationExpression::fp64() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fp64)
  return _internal_fp64();
}
inline ::substrait::Type_FP64* DerivationExpression::unsafe_arena_release_fp64() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fp64)
  if (_internal_has_fp64()) {
    clear_has_kind();
    ::substrait::Type_FP64* temp = kind_.fp64_;
    kind_.fp64_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) {
  clear_kind();
  if (fp64) {
    set_has_fp64();
    kind_.fp64_ = fp64;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fp64)
}
inline ::substrait::Type_FP64* DerivationExpression::_internal_mutable_fp64() {
  if (!_internal_has_fp64()) {
    clear_kind();
    set_has_fp64();
    kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation());
  }
  return kind_.fp64_;
}
inline ::substrait::Type_FP64* DerivationExpression::mutable_fp64() {
  ::substrait::Type_FP64* _msg = _internal_mutable_fp64();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp64)
  return _msg;
}

// .substrait.Type.String string = 12 [json_name = "string"];
inline bool DerivationExpression::_internal_has_string() const {
  return kind_case() == kString;
}
inline bool DerivationExpression::has_string() const {
  return _internal_has_string();
}
inline void DerivationExpression::set_has_string() {
  _oneof_case_[0] = kString;
}
inline ::substrait::Type_String* DerivationExpression::release_string() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.string)
  if (_internal_has_string()) {
    clear_has_kind();
      ::substrait::Type_String* temp = kind_.string_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_String& DerivationExpression::_internal_string() const {
  return _internal_has_string()
      ? *kind_.string_
      : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_);
}
inline const ::substrait::Type_String& DerivationExpression::string() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.string)
  return _internal_string();
}
inline ::substrait::Type_String* DerivationExpression::unsafe_arena_release_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.string)
  if (_internal_has_string()) {
    clear_has_kind();
    ::substrait::Type_String* temp = kind_.string_;
    kind_.string_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_string(::substrait::Type_String* string) {
  clear_kind();
  if (string) {
    set_has_string();
    kind_.string_ = string;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.string)
}
inline ::substrait::Type_String* DerivationExpression::_internal_mutable_string() {
  if (!_internal_has_string()) {
    clear_kind();
    set_has_string();
    kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation());
  }
  return kind_.string_;
}
inline ::substrait::Type_String* DerivationExpression::mutable_string() {
  ::substrait::Type_String* _msg = _internal_mutable_string();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.string)
  return _msg;
}

// .substrait.Type.Binary binary = 13 [json_name = "binary"];
inline bool DerivationExpression::_internal_has_binary() const {
  return kind_case() == kBinary;
}
inline bool DerivationExpression::has_binary() const {
  return _internal_has_binary();
}
inline void DerivationExpression::set_has_binary() {
  _oneof_case_[0] = kBinary;
}
inline ::substrait::Type_Binary* DerivationExpression::release_binary() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.binary)
  if (_internal_has_binary()) {
    clear_has_kind();
      ::substrait::Type_Binary* temp = kind_.binary_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.binary_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_Binary& DerivationExpression::_internal_binary() const {
  return _internal_has_binary()
      ? *kind_.binary_
      : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_);
}
inline const ::substrait::Type_Binary& DerivationExpression::binary() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.binary)
  return _internal_binary();
}
inline ::substrait::Type_Binary* DerivationExpression::unsafe_arena_release_binary() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.binary)
  if (_internal_has_binary()) {
    clear_has_kind();
    ::substrait::Type_Binary* temp = kind_.binary_;
    kind_.binary_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) {
  clear_kind();
  if (binary) {
    set_has_binary();
    kind_.binary_ = binary;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.binary)
}
inline ::substrait::Type_Binary* DerivationExpression::_internal_mutable_binary() {
  if (!_internal_has_binary()) {
    clear_kind();
    set_has_binary();
    kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation());
  }
  return kind_.binary_;
}
inline ::substrait::Type_Binary* DerivationExpression::mutable_binary() {
  ::substrait::Type_Binary* _msg = _internal_mutable_binary();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary)
  return _msg;
}

// .substrait.Type.Timestamp timestamp = 14 [json_name = "timestamp"];
inline bool DerivationExpression::_internal_has_timestamp() const {
  return kind_case() == kTimestamp;
}
inline bool DerivationExpression::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void DerivationExpression::set_has_timestamp() {
  _oneof_case_[0] = kTimestamp;
}
inline ::substrait::Type_Timestamp* DerivationExpression::release_timestamp() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.timestamp)
  if (_internal_has_timestamp()) {
    clear_has_kind();
      ::substrait::Type_Timestamp* temp = kind_.timestamp_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.timestamp_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_Timestamp& DerivationExpression::_internal_timestamp() const {
  return _internal_has_timestamp()
      ? *kind_.timestamp_
      : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_);
}
inline const ::substrait::Type_Timestamp& DerivationExpression::timestamp() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.timestamp)
  return _internal_timestamp();
}
inline ::substrait::Type_Timestamp* DerivationExpression::unsafe_arena_release_timestamp() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.timestamp)
  if (_internal_has_timestamp()) {
    clear_has_kind();
    ::substrait::Type_Timestamp* temp = kind_.timestamp_;
    kind_.timestamp_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) {
  clear_kind();
  if (timestamp) {
    set_has_timestamp();
    kind_.timestamp_ = timestamp;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.timestamp)
}
inline ::substrait::Type_Timestamp* DerivationExpression::_internal_mutable_timestamp() {
  if (!_internal_has_timestamp()) {
    clear_kind();
    set_has_timestamp();
    kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation());
  }
  return kind_.timestamp_;
}
inline ::substrait::Type_Timestamp* DerivationExpression::mutable_timestamp() {
  ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp)
  return _msg;
}

// .substrait.Type.Date date = 16 [json_name = "date"];
inline bool DerivationExpression::_internal_has_date() const {
  return kind_case() == kDate;
}
inline bool DerivationExpression::has_date() const {
  return _internal_has_date();
}
inline void DerivationExpression::set_has_date() {
  _oneof_case_[0] = kDate;
}
inline ::substrait::Type_Date* DerivationExpression::release_date() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.date)
  if (_internal_has_date()) {
    clear_has_kind();
      ::substrait::Type_Date* temp = kind_.date_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.date_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_Date& DerivationExpression::_internal_date() const {
  return _internal_has_date()
      ? *kind_.date_
      : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_);
}
inline const ::substrait::Type_Date& DerivationExpression::date() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.date)
  return _internal_date();
}
inline ::substrait::Type_Date* DerivationExpression::unsafe_arena_release_date() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.date)
  if (_internal_has_date()) {
    clear_has_kind();
    ::substrait::Type_Date* temp = kind_.date_;
    kind_.date_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) {
  clear_kind();
  if (date) {
    set_has_date();
    kind_.date_ = date;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.date)
}
inline ::substrait::Type_Date* DerivationExpression::_internal_mutable_date() {
  if (!_internal_has_date()) {
    clear_kind();
    set_has_date();
    kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation());
  }
  return kind_.date_;
}
inline ::substrait::Type_Date* DerivationExpression::mutable_date() {
  ::substrait::Type_Date* _msg = _internal_mutable_date();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.date)
  return _msg;
}

// .substrait.Type.Time time = 17 [json_name = "time"];
inline bool DerivationExpression::_internal_has_time() const {
  return kind_case() == kTime;
}
inline bool DerivationExpression::has_time() const {
  return _internal_has_time();
}
inline void DerivationExpression::set_has_time() {
  _oneof_case_[0] = kTime;
}
inline ::substrait::Type_Time* DerivationExpression::release_time() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.time)
  if (_internal_has_time()) {
    clear_has_kind();
      ::substrait::Type_Time* temp = kind_.time_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.time_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_Time& DerivationExpression::_internal_time() const {
  return _internal_has_time()
      ? *kind_.time_
      : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_);
}
inline const ::substrait::Type_Time& DerivationExpression::time() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.time)
  return _internal_time();
}
inline ::substrait::Type_Time* DerivationExpression::unsafe_arena_release_time() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.time)
  if (_internal_has_time()) {
    clear_has_kind();
    ::substrait::Type_Time* temp = kind_.time_;
    kind_.time_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) {
  clear_kind();
  if (time) {
    set_has_time();
    kind_.time_ = time;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.time)
}
inline ::substrait::Type_Time* DerivationExpression::_internal_mutable_time() {
  if (!_internal_has_time()) {
    clear_kind();
    set_has_time();
    kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation());
  }
  return kind_.time_;
}
inline ::substrait::Type_Time* DerivationExpression::mutable_time() {
  ::substrait::Type_Time* _msg = _internal_mutable_time();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.time)
  return _msg;
}

// .substrait.Type.IntervalYear interval_year = 19 [json_name = "intervalYear"];
inline bool DerivationExpression::_internal_has_interval_year() const {
  return kind_case() == kIntervalYear;
}
inline bool DerivationExpression::has_interval_year() const {
  return _internal_has_interval_year();
}
inline void DerivationExpression::set_has_interval_year() {
  _oneof_case_[0] = kIntervalYear;
}
inline ::substrait::Type_IntervalYear* DerivationExpression::release_interval_year() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.interval_year)
  if (_internal_has_interval_year()) {
    clear_has_kind();
      ::substrait::Type_IntervalYear* temp = kind_.interval_year_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.interval_year_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_IntervalYear& DerivationExpression::_internal_interval_year() const {
  return _internal_has_interval_year()
      ? *kind_.interval_year_
      : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_);
}
inline const ::substrait::Type_IntervalYear& DerivationExpression::interval_year() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.interval_year)
  return _internal_interval_year();
}
inline ::substrait::Type_IntervalYear* DerivationExpression::unsafe_arena_release_interval_year() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.interval_year)
  if (_internal_has_interval_year()) {
    clear_has_kind();
    ::substrait::Type_IntervalYear* temp = kind_.interval_year_;
    kind_.interval_year_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) {
  clear_kind();
  if (interval_year) {
    set_has_interval_year();
    kind_.interval_year_ = interval_year;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.interval_year)
}
inline ::substrait::Type_IntervalYear* DerivationExpression::_internal_mutable_interval_year() {
  if (!_internal_has_interval_year()) {
    clear_kind();
    set_has_interval_year();
    kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation());
  }
  return kind_.interval_year_;
}
inline ::substrait::Type_IntervalYear* DerivationExpression::mutable_interval_year() {
  ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_year)
  return _msg;
}

// .substrait.Type.IntervalDay interval_day = 20 [json_name = "intervalDay"];
inline bool DerivationExpression::_internal_has_interval_day() const {
  return kind_case() == kIntervalDay;
}
inline bool DerivationExpression::has_interval_day() const {
  return _internal_has_interval_day();
}
inline void DerivationExpression::set_has_interval_day() {
  _oneof_case_[0] = kIntervalDay;
}
inline ::substrait::Type_IntervalDay* DerivationExpression::release_interval_day() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.interval_day)
  if (_internal_has_interval_day()) {
    clear_has_kind();
      ::substrait::Type_IntervalDay* temp = kind_.interval_day_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.interval_day_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_IntervalDay& DerivationExpression::_internal_interval_day() const {
  return _internal_has_interval_day()
      ? *kind_.interval_day_
      : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_);
}
inline const ::substrait::Type_IntervalDay& DerivationExpression::interval_day() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.interval_day)
  return _internal_interval_day();
}
inline ::substrait::Type_IntervalDay* DerivationExpression::unsafe_arena_release_interval_day() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.interval_day)
  if (_internal_has_interval_day()) {
    clear_has_kind();
    ::substrait::Type_IntervalDay* temp = kind_.interval_day_;
    kind_.interval_day_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) {
  clear_kind();
  if (interval_day) {
    set_has_interval_day();
    kind_.interval_day_ = interval_day;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.interval_day)
}
inline ::substrait::Type_IntervalDay* DerivationExpression::_internal_mutable_interval_day() {
  if (!_internal_has_interval_day()) {
    clear_kind();
    set_has_interval_day();
    kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation());
  }
  return kind_.interval_day_;
}
inline ::substrait::Type_IntervalDay* DerivationExpression::mutable_interval_day() {
  ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_day)
  return _msg;
}

// .substrait.Type.TimestampTZ timestamp_tz = 29 [json_name = "timestampTz"];
inline bool DerivationExpression::_internal_has_timestamp_tz() const {
  return kind_case() == kTimestampTz;
}
inline bool DerivationExpression::has_timestamp_tz() const {
  return _internal_has_timestamp_tz();
}
inline void DerivationExpression::set_has_timestamp_tz() {
  _oneof_case_[0] = kTimestampTz;
}
inline ::substrait::Type_TimestampTZ* DerivationExpression::release_timestamp_tz() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.timestamp_tz)
  if (_internal_has_timestamp_tz()) {
    clear_has_kind();
      ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.timestamp_tz_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_TimestampTZ& DerivationExpression::_internal_timestamp_tz() const {
  return _internal_has_timestamp_tz()
      ? *kind_.timestamp_tz_
      : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_);
}
inline const ::substrait::Type_TimestampTZ& DerivationExpression::timestamp_tz() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.timestamp_tz)
  return _internal_timestamp_tz();
}
inline ::substrait::Type_TimestampTZ* DerivationExpression::unsafe_arena_release_timestamp_tz() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.timestamp_tz)
  if (_internal_has_timestamp_tz()) {
    clear_has_kind();
    ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_;
    kind_.timestamp_tz_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) {
  clear_kind();
  if (timestamp_tz) {
    set_has_timestamp_tz();
    kind_.timestamp_tz_ = timestamp_tz;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.timestamp_tz)
}
inline ::substrait::Type_TimestampTZ* DerivationExpression::_internal_mutable_timestamp_tz() {
  if (!_internal_has_timestamp_tz()) {
    clear_kind();
    set_has_timestamp_tz();
    kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation());
  }
  return kind_.timestamp_tz_;
}
inline ::substrait::Type_TimestampTZ* DerivationExpression::mutable_timestamp_tz() {
  ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp_tz)
  return _msg;
}

// .substrait.Type.UUID uuid = 32 [json_name = "uuid"];
inline bool DerivationExpression::_internal_has_uuid() const {
  return kind_case() == kUuid;
}
inline bool DerivationExpression::has_uuid() const {
  return _internal_has_uuid();
}
inline void DerivationExpression::set_has_uuid() {
  _oneof_case_[0] = kUuid;
}
inline ::substrait::Type_UUID* DerivationExpression::release_uuid() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.uuid)
  if (_internal_has_uuid()) {
    clear_has_kind();
      ::substrait::Type_UUID* temp = kind_.uuid_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.uuid_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::Type_UUID& DerivationExpression::_internal_uuid() const {
  return _internal_has_uuid()
      ? *kind_.uuid_
      : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_);
}
inline const ::substrait::Type_UUID& DerivationExpression::uuid() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.uuid)
  return _internal_uuid();
}
inline ::substrait::Type_UUID* DerivationExpression::unsafe_arena_release_uuid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.uuid)
  if (_internal_has_uuid()) {
    clear_has_kind();
    ::substrait::Type_UUID* temp = kind_.uuid_;
    kind_.uuid_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) {
  clear_kind();
  if (uuid) {
    set_has_uuid();
    kind_.uuid_ = uuid;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.uuid)
}
inline ::substrait::Type_UUID* DerivationExpression::_internal_mutable_uuid() {
  if (!_internal_has_uuid()) {
    clear_kind();
    set_has_uuid();
    kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation());
  }
  return kind_.uuid_;
}
inline ::substrait::Type_UUID* DerivationExpression::mutable_uuid() {
  ::substrait::Type_UUID* _msg = _internal_mutable_uuid();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.uuid)
  return _msg;
}

// .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21 [json_name = "fixedChar"];
inline bool DerivationExpression::_internal_has_fixed_char() const {
  return kind_case() == kFixedChar;
}
inline bool DerivationExpression::has_fixed_char() const {
  return _internal_has_fixed_char();
}
inline void DerivationExpression::set_has_fixed_char() {
  _oneof_case_[0] = kFixedChar;
}
inline void DerivationExpression::clear_fixed_char() {
  if (_internal_has_fixed_char()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.fixed_char_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::release_fixed_char() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fixed_char)
  if (_internal_has_fixed_char()) {
    clear_has_kind();
      ::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.fixed_char_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::_internal_fixed_char() const {
  return _internal_has_fixed_char()
      ? *kind_.fixed_char_
      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionFixedChar&>(::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_);
}
inline const ::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::fixed_char() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fixed_char)
  return _internal_fixed_char();
}
inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::unsafe_arena_release_fixed_char() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fixed_char)
  if (_internal_has_fixed_char()) {
    clear_has_kind();
    ::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_;
    kind_.fixed_char_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) {
  clear_kind();
  if (fixed_char) {
    set_has_fixed_char();
    kind_.fixed_char_ = fixed_char;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fixed_char)
}
inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::_internal_mutable_fixed_char() {
  if (!_internal_has_fixed_char()) {
    clear_kind();
    set_has_fixed_char();
    kind_.fixed_char_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(GetArenaForAllocation());
  }
  return kind_.fixed_char_;
}
inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::mutable_fixed_char() {
  ::substrait::DerivationExpression_ExpressionFixedChar* _msg = _internal_mutable_fixed_char();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_char)
  return _msg;
}

// .substrait.DerivationExpression.ExpressionVarChar varchar = 22 [json_name = "varchar"];
inline bool DerivationExpression::_internal_has_varchar() const {
  return kind_case() == kVarchar;
}
inline bool DerivationExpression::has_varchar() const {
  return _internal_has_varchar();
}
inline void DerivationExpression::set_has_varchar() {
  _oneof_case_[0] = kVarchar;
}
inline void DerivationExpression::clear_varchar() {
  if (_internal_has_varchar()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.varchar_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::release_varchar() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.varchar)
  if (_internal_has_varchar()) {
    clear_has_kind();
      ::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.varchar_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::_internal_varchar() const {
  return _internal_has_varchar()
      ? *kind_.varchar_
      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionVarChar&>(::substrait::_DerivationExpression_ExpressionVarChar_default_instance_);
}
inline const ::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::varchar() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.varchar)
  return _internal_varchar();
}
inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::unsafe_arena_release_varchar() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.varchar)
  if (_internal_has_varchar()) {
    clear_has_kind();
    ::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_;
    kind_.varchar_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar) {
  clear_kind();
  if (varchar) {
    set_has_varchar();
    kind_.varchar_ = varchar;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.varchar)
}
inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::_internal_mutable_varchar() {
  if (!_internal_has_varchar()) {
    clear_kind();
    set_has_varchar();
    kind_.varchar_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(GetArenaForAllocation());
  }
  return kind_.varchar_;
}
inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::mutable_varchar() {
  ::substrait::DerivationExpression_ExpressionVarChar* _msg = _internal_mutable_varchar();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.varchar)
  return _msg;
}

// .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23 [json_name = "fixedBinary"];
inline bool DerivationExpression::_internal_has_fixed_binary() const {
  return kind_case() == kFixedBinary;
}
inline bool DerivationExpression::has_fixed_binary() const {
  return _internal_has_fixed_binary();
}
inline void DerivationExpression::set_has_fixed_binary() {
  _oneof_case_[0] = kFixedBinary;
}
inline void DerivationExpression::clear_fixed_binary() {
  if (_internal_has_fixed_binary()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.fixed_binary_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::release_fixed_binary() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fixed_binary)
  if (_internal_has_fixed_binary()) {
    clear_has_kind();
      ::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.fixed_binary_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::_internal_fixed_binary() const {
  return _internal_has_fixed_binary()
      ? *kind_.fixed_binary_
      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionFixedBinary&>(::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_);
}
inline const ::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::fixed_binary() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fixed_binary)
  return _internal_fixed_binary();
}
inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::unsafe_arena_release_fixed_binary() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fixed_binary)
  if (_internal_has_fixed_binary()) {
    clear_has_kind();
    ::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_;
    kind_.fixed_binary_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) {
  clear_kind();
  if (fixed_binary) {
    set_has_fixed_binary();
    kind_.fixed_binary_ = fixed_binary;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fixed_binary)
}
inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::_internal_mutable_fixed_binary() {
  if (!_internal_has_fixed_binary()) {
    clear_kind();
    set_has_fixed_binary();
    kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(GetArenaForAllocation());
  }
  return kind_.fixed_binary_;
}
inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::mutable_fixed_binary() {
  ::substrait::DerivationExpression_ExpressionFixedBinary* _msg = _internal_mutable_fixed_binary();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_binary)
  return _msg;
}

// .substrait.DerivationExpression.ExpressionDecimal decimal = 24 [json_name = "decimal"];
inline bool DerivationExpression::_internal_has_decimal() const {
  return kind_case() == kDecimal;
}
inline bool DerivationExpression::has_decimal() const {
  return _internal_has_decimal();
}
inline void DerivationExpression::set_has_decimal() {
  _oneof_case_[0] = kDecimal;
}
inline void DerivationExpression::clear_decimal() {
  if (_internal_has_decimal()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.decimal_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::release_decimal() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.decimal)
  if (_internal_has_decimal()) {
    clear_has_kind();
      ::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.decimal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::_internal_decimal() const {
  return _internal_has_decimal()
      ? *kind_.decimal_
      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionDecimal&>(::substrait::_DerivationExpression_ExpressionDecimal_default_instance_);
}
inline const ::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::decimal() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.decimal)
  return _internal_decimal();
}
inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::unsafe_arena_release_decimal() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.decimal)
  if (_internal_has_decimal()) {
    clear_has_kind();
    ::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_;
    kind_.decimal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal) {
  clear_kind();
  if (decimal) {
    set_has_decimal();
    kind_.decimal_ = decimal;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.decimal)
}
inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::_internal_mutable_decimal() {
  if (!_internal_has_decimal()) {
    clear_kind();
    set_has_decimal();
    kind_.decimal_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(GetArenaForAllocation());
  }
  return kind_.decimal_;
}
inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::mutable_decimal() {
  ::substrait::DerivationExpression_ExpressionDecimal* _msg = _internal_mutable_decimal();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.decimal)
  return _msg;
}

// .substrait.DerivationExpression.ExpressionStruct struct = 25 [json_name = "struct"];
inline bool DerivationExpression::_internal_has_struct_() const {
  return kind_case() == kStruct;
}
inline bool DerivationExpression::has_struct_() const {
  return _internal_has_struct_();
}
inline void DerivationExpression::set_has_struct_() {
  _oneof_case_[0] = kStruct;
}
inline void DerivationExpression::clear_struct_() {
  if (_internal_has_struct_()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.struct__;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::release_struct_() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.struct)
  if (_internal_has_struct_()) {
    clear_has_kind();
      ::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.struct__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::_internal_struct_() const {
  return _internal_has_struct_()
      ? *kind_.struct__
      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionStruct&>(::substrait::_DerivationExpression_ExpressionStruct_default_instance_);
}
inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::struct_() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.struct)
  return _internal_struct_();
}
inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::unsafe_arena_release_struct_() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.struct)
  if (_internal_has_struct_()) {
    clear_has_kind();
    ::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__;
    kind_.struct__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) {
  clear_kind();
  if (struct_) {
    set_has_struct_();
    kind_.struct__ = struct_;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.struct)
}
inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::_internal_mutable_struct_() {
  if (!_internal_has_struct_()) {
    clear_kind();
    set_has_struct_();
    kind_.struct__ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(GetArenaForAllocation());
  }
  return kind_.struct__;
}
inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::mutable_struct_() {
  ::substrait::DerivationExpression_ExpressionStruct* _msg = _internal_mutable_struct_();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.struct)
  return _msg;
}

// .substrait.DerivationExpression.ExpressionList list = 27 [json_name = "list"];
inline bool DerivationExpression::_internal_has_list() const {
  return kind_case() == kList;
}
inline bool DerivationExpression::has_list() const {
  return _internal_has_list();
}
inline void DerivationExpression::set_has_list() {
  _oneof_case_[0] = kList;
}
inline void DerivationExpression::clear_list() {
  if (_internal_has_list()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.list_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::release_list() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.list)
  if (_internal_has_list()) {
    clear_has_kind();
      ::substrait::DerivationExpression_ExpressionList* temp = kind_.list_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_ExpressionList& DerivationExpression::_internal_list() const {
  return _internal_has_list()
      ? *kind_.list_
      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionList&>(::substrait::_DerivationExpression_ExpressionList_default_instance_);
}
inline const ::substrait::DerivationExpression_ExpressionList& DerivationExpression::list() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.list)
  return _internal_list();
}
inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::unsafe_arena_release_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.list)
  if (_internal_has_list()) {
    clear_has_kind();
    ::substrait::DerivationExpression_ExpressionList* temp = kind_.list_;
    kind_.list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_list(::substrait::DerivationExpression_ExpressionList* list) {
  clear_kind();
  if (list) {
    set_has_list();
    kind_.list_ = list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.list)
}
inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::_internal_mutable_list() {
  if (!_internal_has_list()) {
    clear_kind();
    set_has_list();
    kind_.list_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(GetArenaForAllocation());
  }
  return kind_.list_;
}
inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::mutable_list() {
  ::substrait::DerivationExpression_ExpressionList* _msg = _internal_mutable_list();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.list)
  return _msg;
}

// .substrait.DerivationExpression.ExpressionMap map = 28 [json_name = "map"];
inline bool DerivationExpression::_internal_has_map() const {
  return kind_case() == kMap;
}
inline bool DerivationExpression::has_map() const {
  return _internal_has_map();
}
inline void DerivationExpression::set_has_map() {
  _oneof_case_[0] = kMap;
}
inline void DerivationExpression::clear_map() {
  if (_internal_has_map()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.map_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::release_map() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.map)
  if (_internal_has_map()) {
    clear_has_kind();
      ::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_ExpressionMap& DerivationExpression::_internal_map() const {
  return _internal_has_map()
      ? *kind_.map_
      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionMap&>(::substrait::_DerivationExpression_ExpressionMap_default_instance_);
}
inline const ::substrait::DerivationExpression_ExpressionMap& DerivationExpression::map() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.map)
  return _internal_map();
}
inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::unsafe_arena_release_map() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.map)
  if (_internal_has_map()) {
    clear_has_kind();
    ::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_;
    kind_.map_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map) {
  clear_kind();
  if (map) {
    set_has_map();
    kind_.map_ = map;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.map)
}
inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::_internal_mutable_map() {
  if (!_internal_has_map()) {
    clear_kind();
    set_has_map();
    kind_.map_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(GetArenaForAllocation());
  }
  return kind_.map_;
}
inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::mutable_map() {
  ::substrait::DerivationExpression_ExpressionMap* _msg = _internal_mutable_map();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.map)
  return _msg;
}

// uint32 user_defined_pointer = 31 [json_name = "userDefinedPointer"];
inline bool DerivationExpression::_internal_has_user_defined_pointer() const {
  return kind_case() == kUserDefinedPointer;
}
inline bool DerivationExpression::has_user_defined_pointer() const {
  return _internal_has_user_defined_pointer();
}
inline void DerivationExpression::set_has_user_defined_pointer() {
  _oneof_case_[0] = kUserDefinedPointer;
}
inline void DerivationExpression::clear_user_defined_pointer() {
  if (_internal_has_user_defined_pointer()) {
    kind_.user_defined_pointer_ = 0u;
    clear_has_kind();
  }
}
inline uint32_t DerivationExpression::_internal_user_defined_pointer() const {
  if (_internal_has_user_defined_pointer()) {
    return kind_.user_defined_pointer_;
  }
  return 0u;
}
inline void DerivationExpression::_internal_set_user_defined_pointer(uint32_t value) {
  if (!_internal_has_user_defined_pointer()) {
    clear_kind();
    set_has_user_defined_pointer();
  }
  kind_.user_defined_pointer_ = value;
}
inline uint32_t DerivationExpression::user_defined_pointer() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.user_defined_pointer)
  return _internal_user_defined_pointer();
}
inline void DerivationExpression::set_user_defined_pointer(uint32_t value) {
  _internal_set_user_defined_pointer(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.user_defined_pointer)
}

// string type_parameter_name = 33 [json_name = "typeParameterName"];
inline bool DerivationExpression::_internal_has_type_parameter_name() const {
  return kind_case() == kTypeParameterName;
}
inline bool DerivationExpression::has_type_parameter_name() const {
  return _internal_has_type_parameter_name();
}
inline void DerivationExpression::set_has_type_parameter_name() {
  _oneof_case_[0] = kTypeParameterName;
}
inline void DerivationExpression::clear_type_parameter_name() {
  if (_internal_has_type_parameter_name()) {
    kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_kind();
  }
}
inline const std::string& DerivationExpression::type_parameter_name() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.type_parameter_name)
  return _internal_type_parameter_name();
}
template <typename ArgT0, typename... ArgT>
inline void DerivationExpression::set_type_parameter_name(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_type_parameter_name()) {
    clear_kind();
    set_has_type_parameter_name();
    kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.type_parameter_name)
}
inline std::string* DerivationExpression::mutable_type_parameter_name() {
  std::string* _s = _internal_mutable_type_parameter_name();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.type_parameter_name)
  return _s;
}
inline const std::string& DerivationExpression::_internal_type_parameter_name() const {
  if (_internal_has_type_parameter_name()) {
    return kind_.type_parameter_name_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void DerivationExpression::_internal_set_type_parameter_name(const std::string& value) {
  if (!_internal_has_type_parameter_name()) {
    clear_kind();
    set_has_type_parameter_name();
    kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DerivationExpression::_internal_mutable_type_parameter_name() {
  if (!_internal_has_type_parameter_name()) {
    clear_kind();
    set_has_type_parameter_name();
    kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return kind_.type_parameter_name_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DerivationExpression::release_type_parameter_name() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.type_parameter_name)
  if (_internal_has_type_parameter_name()) {
    clear_has_kind();
    return kind_.type_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::set_allocated_type_parameter_name(std::string* type_parameter_name) {
  if (has_kind()) {
    clear_kind();
  }
  if (type_parameter_name != nullptr) {
    set_has_type_parameter_name();
    kind_.type_parameter_name_.UnsafeSetDefault(type_parameter_name);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(type_parameter_name);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.type_parameter_name)
}

// string integer_parameter_name = 34 [json_name = "integerParameterName"];
inline bool DerivationExpression::_internal_has_integer_parameter_name() const {
  return kind_case() == kIntegerParameterName;
}
inline bool DerivationExpression::has_integer_parameter_name() const {
  return _internal_has_integer_parameter_name();
}
inline void DerivationExpression::set_has_integer_parameter_name() {
  _oneof_case_[0] = kIntegerParameterName;
}
inline void DerivationExpression::clear_integer_parameter_name() {
  if (_internal_has_integer_parameter_name()) {
    kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_kind();
  }
}
inline const std::string& DerivationExpression::integer_parameter_name() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.integer_parameter_name)
  return _internal_integer_parameter_name();
}
template <typename ArgT0, typename... ArgT>
inline void DerivationExpression::set_integer_parameter_name(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_integer_parameter_name()) {
    clear_kind();
    set_has_integer_parameter_name();
    kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_parameter_name)
}
inline std::string* DerivationExpression::mutable_integer_parameter_name() {
  std::string* _s = _internal_mutable_integer_parameter_name();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.integer_parameter_name)
  return _s;
}
inline const std::string& DerivationExpression::_internal_integer_parameter_name() const {
  if (_internal_has_integer_parameter_name()) {
    return kind_.integer_parameter_name_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void DerivationExpression::_internal_set_integer_parameter_name(const std::string& value) {
  if (!_internal_has_integer_parameter_name()) {
    clear_kind();
    set_has_integer_parameter_name();
    kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DerivationExpression::_internal_mutable_integer_parameter_name() {
  if (!_internal_has_integer_parameter_name()) {
    clear_kind();
    set_has_integer_parameter_name();
    kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return kind_.integer_parameter_name_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DerivationExpression::release_integer_parameter_name() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.integer_parameter_name)
  if (_internal_has_integer_parameter_name()) {
    clear_has_kind();
    return kind_.integer_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::set_allocated_integer_parameter_name(std::string* integer_parameter_name) {
  if (has_kind()) {
    clear_kind();
  }
  if (integer_parameter_name != nullptr) {
    set_has_integer_parameter_name();
    kind_.integer_parameter_name_.UnsafeSetDefault(integer_parameter_name);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(integer_parameter_name);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.integer_parameter_name)
}

// int32 integer_literal = 35 [json_name = "integerLiteral"];
inline bool DerivationExpression::_internal_has_integer_literal() const {
  return kind_case() == kIntegerLiteral;
}
inline bool DerivationExpression::has_integer_literal() const {
  return _internal_has_integer_literal();
}
inline void DerivationExpression::set_has_integer_literal() {
  _oneof_case_[0] = kIntegerLiteral;
}
inline void DerivationExpression::clear_integer_literal() {
  if (_internal_has_integer_literal()) {
    kind_.integer_literal_ = 0;
    clear_has_kind();
  }
}
inline int32_t DerivationExpression::_internal_integer_literal() const {
  if (_internal_has_integer_literal()) {
    return kind_.integer_literal_;
  }
  return 0;
}
inline void DerivationExpression::_internal_set_integer_literal(int32_t value) {
  if (!_internal_has_integer_literal()) {
    clear_kind();
    set_has_integer_literal();
  }
  kind_.integer_literal_ = value;
}
inline int32_t DerivationExpression::integer_literal() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.integer_literal)
  return _internal_integer_literal();
}
inline void DerivationExpression::set_integer_literal(int32_t value) {
  _internal_set_integer_literal(value);
  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_literal)
}

// .substrait.DerivationExpression.UnaryOp unary_op = 36 [json_name = "unaryOp"];
inline bool DerivationExpression::_internal_has_unary_op() const {
  return kind_case() == kUnaryOp;
}
inline bool DerivationExpression::has_unary_op() const {
  return _internal_has_unary_op();
}
inline void DerivationExpression::set_has_unary_op() {
  _oneof_case_[0] = kUnaryOp;
}
inline void DerivationExpression::clear_unary_op() {
  if (_internal_has_unary_op()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.unary_op_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::release_unary_op() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.unary_op)
  if (_internal_has_unary_op()) {
    clear_has_kind();
      ::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.unary_op_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_UnaryOp& DerivationExpression::_internal_unary_op() const {
  return _internal_has_unary_op()
      ? *kind_.unary_op_
      : reinterpret_cast< ::substrait::DerivationExpression_UnaryOp&>(::substrait::_DerivationExpression_UnaryOp_default_instance_);
}
inline const ::substrait::DerivationExpression_UnaryOp& DerivationExpression::unary_op() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.unary_op)
  return _internal_unary_op();
}
inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::unsafe_arena_release_unary_op() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.unary_op)
  if (_internal_has_unary_op()) {
    clear_has_kind();
    ::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_;
    kind_.unary_op_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op) {
  clear_kind();
  if (unary_op) {
    set_has_unary_op();
    kind_.unary_op_ = unary_op;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.unary_op)
}
inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::_internal_mutable_unary_op() {
  if (!_internal_has_unary_op()) {
    clear_kind();
    set_has_unary_op();
    kind_.unary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(GetArenaForAllocation());
  }
  return kind_.unary_op_;
}
inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::mutable_unary_op() {
  ::substrait::DerivationExpression_UnaryOp* _msg = _internal_mutable_unary_op();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.unary_op)
  return _msg;
}

// .substrait.DerivationExpression.BinaryOp binary_op = 37 [json_name = "binaryOp"];
inline bool DerivationExpression::_internal_has_binary_op() const {
  return kind_case() == kBinaryOp;
}
inline bool DerivationExpression::has_binary_op() const {
  return _internal_has_binary_op();
}
inline void DerivationExpression::set_has_binary_op() {
  _oneof_case_[0] = kBinaryOp;
}
inline void DerivationExpression::clear_binary_op() {
  if (_internal_has_binary_op()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.binary_op_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::release_binary_op() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.binary_op)
  if (_internal_has_binary_op()) {
    clear_has_kind();
      ::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.binary_op_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_BinaryOp& DerivationExpression::_internal_binary_op() const {
  return _internal_has_binary_op()
      ? *kind_.binary_op_
      : reinterpret_cast< ::substrait::DerivationExpression_BinaryOp&>(::substrait::_DerivationExpression_BinaryOp_default_instance_);
}
inline const ::substrait::DerivationExpression_BinaryOp& DerivationExpression::binary_op() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.binary_op)
  return _internal_binary_op();
}
inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::unsafe_arena_release_binary_op() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.binary_op)
  if (_internal_has_binary_op()) {
    clear_has_kind();
    ::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_;
    kind_.binary_op_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op) {
  clear_kind();
  if (binary_op) {
    set_has_binary_op();
    kind_.binary_op_ = binary_op;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.binary_op)
}
inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::_internal_mutable_binary_op() {
  if (!_internal_has_binary_op()) {
    clear_kind();
    set_has_binary_op();
    kind_.binary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(GetArenaForAllocation());
  }
  return kind_.binary_op_;
}
inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::mutable_binary_op() {
  ::substrait::DerivationExpression_BinaryOp* _msg = _internal_mutable_binary_op();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary_op)
  return _msg;
}

// .substrait.DerivationExpression.IfElse if_else = 38 [json_name = "ifElse"];
inline bool DerivationExpression::_internal_has_if_else() const {
  return kind_case() == kIfElse;
}
inline bool DerivationExpression::has_if_else() const {
  return _internal_has_if_else();
}
inline void DerivationExpression::set_has_if_else() {
  _oneof_case_[0] = kIfElse;
}
inline void DerivationExpression::clear_if_else() {
  if (_internal_has_if_else()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.if_else_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_IfElse* DerivationExpression::release_if_else() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.if_else)
  if (_internal_has_if_else()) {
    clear_has_kind();
      ::substrait::DerivationExpression_IfElse* temp = kind_.if_else_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.if_else_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_IfElse& DerivationExpression::_internal_if_else() const {
  return _internal_has_if_else()
      ? *kind_.if_else_
      : reinterpret_cast< ::substrait::DerivationExpression_IfElse&>(::substrait::_DerivationExpression_IfElse_default_instance_);
}
inline const ::substrait::DerivationExpression_IfElse& DerivationExpression::if_else() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.if_else)
  return _internal_if_else();
}
inline ::substrait::DerivationExpression_IfElse* DerivationExpression::unsafe_arena_release_if_else() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.if_else)
  if (_internal_has_if_else()) {
    clear_has_kind();
    ::substrait::DerivationExpression_IfElse* temp = kind_.if_else_;
    kind_.if_else_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else) {
  clear_kind();
  if (if_else) {
    set_has_if_else();
    kind_.if_else_ = if_else;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.if_else)
}
inline ::substrait::DerivationExpression_IfElse* DerivationExpression::_internal_mutable_if_else() {
  if (!_internal_has_if_else()) {
    clear_kind();
    set_has_if_else();
    kind_.if_else_ = CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(GetArenaForAllocation());
  }
  return kind_.if_else_;
}
inline ::substrait::DerivationExpression_IfElse* DerivationExpression::mutable_if_else() {
  ::substrait::DerivationExpression_IfElse* _msg = _internal_mutable_if_else();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.if_else)
  return _msg;
}

// .substrait.DerivationExpression.ReturnProgram return_program = 39 [json_name = "returnProgram"];
inline bool DerivationExpression::_internal_has_return_program() const {
  return kind_case() == kReturnProgram;
}
inline bool DerivationExpression::has_return_program() const {
  return _internal_has_return_program();
}
inline void DerivationExpression::set_has_return_program() {
  _oneof_case_[0] = kReturnProgram;
}
inline void DerivationExpression::clear_return_program() {
  if (_internal_has_return_program()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.return_program_;
    }
    clear_has_kind();
  }
}
inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::release_return_program() {
  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.return_program)
  if (_internal_has_return_program()) {
    clear_has_kind();
      ::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kind_.return_program_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::DerivationExpression_ReturnProgram& DerivationExpression::_internal_return_program() const {
  return _internal_has_return_program()
      ? *kind_.return_program_
      : reinterpret_cast< ::substrait::DerivationExpression_ReturnProgram&>(::substrait::_DerivationExpression_ReturnProgram_default_instance_);
}
inline const ::substrait::DerivationExpression_ReturnProgram& DerivationExpression::return_program() const {
  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.return_program)
  return _internal_return_program();
}
inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::unsafe_arena_release_return_program() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.return_program)
  if (_internal_has_return_program()) {
    clear_has_kind();
    ::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_;
    kind_.return_program_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void DerivationExpression::unsafe_arena_set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program) {
  clear_kind();
  if (return_program) {
    set_has_return_program();
    kind_.return_program_ = return_program;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.return_program)
}
inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::_internal_mutable_return_program() {
  if (!_internal_has_return_program()) {
    clear_kind();
    set_has_return_program();
    kind_.return_program_ = CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(GetArenaForAllocation());
  }
  return kind_.return_program_;
}
inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::mutable_return_program() {
  ::substrait::DerivationExpression_ReturnProgram* _msg = _internal_mutable_return_program();
  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.return_program)
  return _msg;
}

inline bool DerivationExpression::has_kind() const {
  return kind_case() != KIND_NOT_SET;
}
inline void DerivationExpression::clear_has_kind() {
  _oneof_case_[0] = KIND_NOT_SET;
}
inline DerivationExpression::KindCase DerivationExpression::kind_case() const {
  return DerivationExpression::KindCase(_oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace substrait

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::substrait::DerivationExpression_UnaryOp_UnaryOpType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::substrait::DerivationExpression_UnaryOp_UnaryOpType>() {
  return ::substrait::DerivationExpression_UnaryOp_UnaryOpType_descriptor();
}
template <> struct is_proto_enum< ::substrait::DerivationExpression_BinaryOp_BinaryOpType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::substrait::DerivationExpression_BinaryOp_BinaryOpType>() {
  return ::substrait::DerivationExpression_BinaryOp_BinaryOpType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto
