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

#include "substrait/type_expressions.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace substrait {
constexpr DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : length_(nullptr)
  , variation_pointer_(0u)
  , nullability_(0)
{}
struct DerivationExpression_ExpressionFixedCharDefaultTypeInternal {
  constexpr DerivationExpression_ExpressionFixedCharDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ExpressionFixedCharDefaultTypeInternal() {}
  union {
    DerivationExpression_ExpressionFixedChar _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionFixedCharDefaultTypeInternal _DerivationExpression_ExpressionFixedChar_default_instance_;
constexpr DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : length_(nullptr)
  , variation_pointer_(0u)
  , nullability_(0)
{}
struct DerivationExpression_ExpressionVarCharDefaultTypeInternal {
  constexpr DerivationExpression_ExpressionVarCharDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ExpressionVarCharDefaultTypeInternal() {}
  union {
    DerivationExpression_ExpressionVarChar _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionVarCharDefaultTypeInternal _DerivationExpression_ExpressionVarChar_default_instance_;
constexpr DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : length_(nullptr)
  , variation_pointer_(0u)
  , nullability_(0)
{}
struct DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal {
  constexpr DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal() {}
  union {
    DerivationExpression_ExpressionFixedBinary _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal _DerivationExpression_ExpressionFixedBinary_default_instance_;
constexpr DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : scale_(nullptr)
  , precision_(nullptr)
  , variation_pointer_(0u)
  , nullability_(0)
{}
struct DerivationExpression_ExpressionDecimalDefaultTypeInternal {
  constexpr DerivationExpression_ExpressionDecimalDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ExpressionDecimalDefaultTypeInternal() {}
  union {
    DerivationExpression_ExpressionDecimal _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionDecimalDefaultTypeInternal _DerivationExpression_ExpressionDecimal_default_instance_;
constexpr DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : types_()
  , variation_pointer_(0u)
  , nullability_(0)
{}
struct DerivationExpression_ExpressionStructDefaultTypeInternal {
  constexpr DerivationExpression_ExpressionStructDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ExpressionStructDefaultTypeInternal() {}
  union {
    DerivationExpression_ExpressionStruct _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionStructDefaultTypeInternal _DerivationExpression_ExpressionStruct_default_instance_;
constexpr DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : names_()
  , struct__(nullptr){}
struct DerivationExpression_ExpressionNamedStructDefaultTypeInternal {
  constexpr DerivationExpression_ExpressionNamedStructDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ExpressionNamedStructDefaultTypeInternal() {}
  union {
    DerivationExpression_ExpressionNamedStruct _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionNamedStructDefaultTypeInternal _DerivationExpression_ExpressionNamedStruct_default_instance_;
constexpr DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : type_(nullptr)
  , variation_pointer_(0u)
  , nullability_(0)
{}
struct DerivationExpression_ExpressionListDefaultTypeInternal {
  constexpr DerivationExpression_ExpressionListDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ExpressionListDefaultTypeInternal() {}
  union {
    DerivationExpression_ExpressionList _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionListDefaultTypeInternal _DerivationExpression_ExpressionList_default_instance_;
constexpr DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : key_(nullptr)
  , value_(nullptr)
  , variation_pointer_(0u)
  , nullability_(0)
{}
struct DerivationExpression_ExpressionMapDefaultTypeInternal {
  constexpr DerivationExpression_ExpressionMapDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ExpressionMapDefaultTypeInternal() {}
  union {
    DerivationExpression_ExpressionMap _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionMapDefaultTypeInternal _DerivationExpression_ExpressionMap_default_instance_;
constexpr DerivationExpression_IfElse::DerivationExpression_IfElse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : if_condition_(nullptr)
  , if_return_(nullptr)
  , else_return_(nullptr){}
struct DerivationExpression_IfElseDefaultTypeInternal {
  constexpr DerivationExpression_IfElseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_IfElseDefaultTypeInternal() {}
  union {
    DerivationExpression_IfElse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_IfElseDefaultTypeInternal _DerivationExpression_IfElse_default_instance_;
constexpr DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : arg_(nullptr)
  , op_type_(0)
{}
struct DerivationExpression_UnaryOpDefaultTypeInternal {
  constexpr DerivationExpression_UnaryOpDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_UnaryOpDefaultTypeInternal() {}
  union {
    DerivationExpression_UnaryOp _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_;
constexpr DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : arg1_(nullptr)
  , arg2_(nullptr)
  , op_type_(0)
{}
struct DerivationExpression_BinaryOpDefaultTypeInternal {
  constexpr DerivationExpression_BinaryOpDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_BinaryOpDefaultTypeInternal() {}
  union {
    DerivationExpression_BinaryOp _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_BinaryOpDefaultTypeInternal _DerivationExpression_BinaryOp_default_instance_;
constexpr DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , expression_(nullptr){}
struct DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal {
  constexpr DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal() {}
  union {
    DerivationExpression_ReturnProgram_Assignment _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal _DerivationExpression_ReturnProgram_Assignment_default_instance_;
constexpr DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : assignments_()
  , final_expression_(nullptr){}
struct DerivationExpression_ReturnProgramDefaultTypeInternal {
  constexpr DerivationExpression_ReturnProgramDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpression_ReturnProgramDefaultTypeInternal() {}
  union {
    DerivationExpression_ReturnProgram _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ReturnProgramDefaultTypeInternal _DerivationExpression_ReturnProgram_default_instance_;
constexpr DerivationExpression::DerivationExpression(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct DerivationExpressionDefaultTypeInternal {
  constexpr DerivationExpressionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~DerivationExpressionDefaultTypeInternal() {}
  union {
    DerivationExpression _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_;
}  // namespace substrait
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ftype_5fexpressions_2eproto[14];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[2];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ftype_5fexpressions_2eproto = nullptr;

const uint32_t TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, length_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, variation_pointer_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, nullability_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, length_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, variation_pointer_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, nullability_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, length_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, variation_pointer_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, nullability_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, scale_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, precision_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, variation_pointer_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, nullability_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, types_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, variation_pointer_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, nullability_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, names_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, struct__),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, type_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, variation_pointer_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, nullability_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, key_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, value_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, variation_pointer_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, nullability_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_condition_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_return_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, else_return_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, op_type_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, arg_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, op_type_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg1_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg2_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, name_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, expression_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, assignments_),
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, final_expression_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, kind_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedChar)},
  { 9, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionVarChar)},
  { 18, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedBinary)},
  { 27, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionDecimal)},
  { 37, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionStruct)},
  { 46, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionNamedStruct)},
  { 54, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionList)},
  { 63, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionMap)},
  { 73, -1, -1, sizeof(::substrait::DerivationExpression_IfElse)},
  { 82, -1, -1, sizeof(::substrait::DerivationExpression_UnaryOp)},
  { 90, -1, -1, sizeof(::substrait::DerivationExpression_BinaryOp)},
  { 99, -1, -1, sizeof(::substrait::DerivationExpression_ReturnProgram_Assignment)},
  { 107, -1, -1, sizeof(::substrait::DerivationExpression_ReturnProgram)},
  { 115, -1, -1, sizeof(::substrait::DerivationExpression)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionVarChar_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionDecimal_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionStruct_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionNamedStruct_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionList_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionMap_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_IfElse_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_UnaryOp_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_BinaryOp_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ReturnProgram_Assignment_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ReturnProgram_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_default_instance_),
};

const char descriptor_table_protodef_substrait_2ftype_5fexpressions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n substrait/type_expressions.proto\022\tsubs"
  "trait\032\024substrait/type.proto\"\303$\n\024Derivati"
  "onExpression\022-\n\004bool\030\001 \001(\0132\027.substrait.T"
  "ype.BooleanH\000R\004bool\022$\n\002i8\030\002 \001(\0132\022.substr"
  "ait.Type.I8H\000R\002i8\022\'\n\003i16\030\003 \001(\0132\023.substra"
  "it.Type.I16H\000R\003i16\022\'\n\003i32\030\005 \001(\0132\023.substr"
  "ait.Type.I32H\000R\003i32\022\'\n\003i64\030\007 \001(\0132\023.subst"
  "rait.Type.I64H\000R\003i64\022*\n\004fp32\030\n \001(\0132\024.sub"
  "strait.Type.FP32H\000R\004fp32\022*\n\004fp64\030\013 \001(\0132\024"
  ".substrait.Type.FP64H\000R\004fp64\0220\n\006string\030\014"
  " \001(\0132\026.substrait.Type.StringH\000R\006string\0220"
  "\n\006binary\030\r \001(\0132\026.substrait.Type.BinaryH\000"
  "R\006binary\0229\n\ttimestamp\030\016 \001(\0132\031.substrait."
  "Type.TimestampH\000R\ttimestamp\022*\n\004date\030\020 \001("
  "\0132\024.substrait.Type.DateH\000R\004date\022*\n\004time\030"
  "\021 \001(\0132\024.substrait.Type.TimeH\000R\004time\022C\n\ri"
  "nterval_year\030\023 \001(\0132\034.substrait.Type.Inte"
  "rvalYearH\000R\014intervalYear\022@\n\014interval_day"
  "\030\024 \001(\0132\033.substrait.Type.IntervalDayH\000R\013i"
  "ntervalDay\022@\n\014timestamp_tz\030\035 \001(\0132\033.subst"
  "rait.Type.TimestampTZH\000R\013timestampTz\022*\n\004"
  "uuid\030  \001(\0132\024.substrait.Type.UUIDH\000R\004uuid"
  "\022T\n\nfixed_char\030\025 \001(\01323.substrait.Derivat"
  "ionExpression.ExpressionFixedCharH\000R\tfix"
  "edChar\022M\n\007varchar\030\026 \001(\01321.substrait.Deri"
  "vationExpression.ExpressionVarCharH\000R\007va"
  "rchar\022Z\n\014fixed_binary\030\027 \001(\01325.substrait."
  "DerivationExpression.ExpressionFixedBina"
  "ryH\000R\013fixedBinary\022M\n\007decimal\030\030 \001(\01321.sub"
  "strait.DerivationExpression.ExpressionDe"
  "cimalH\000R\007decimal\022J\n\006struct\030\031 \001(\01320.subst"
  "rait.DerivationExpression.ExpressionStru"
  "ctH\000R\006struct\022D\n\004list\030\033 \001(\0132..substrait.D"
  "erivationExpression.ExpressionListH\000R\004li"
  "st\022A\n\003map\030\034 \001(\0132-.substrait.DerivationEx"
  "pression.ExpressionMapH\000R\003map\0222\n\024user_de"
  "fined_pointer\030\037 \001(\rH\000R\022userDefinedPointe"
  "r\0220\n\023type_parameter_name\030! \001(\tH\000R\021typePa"
  "rameterName\0226\n\026integer_parameter_name\030\" "
  "\001(\tH\000R\024integerParameterName\022)\n\017integer_l"
  "iteral\030# \001(\005H\000R\016integerLiteral\022D\n\010unary_"
  "op\030$ \001(\0132\'.substrait.DerivationExpressio"
  "n.UnaryOpH\000R\007unaryOp\022G\n\tbinary_op\030% \001(\0132"
  "(.substrait.DerivationExpression.BinaryO"
  "pH\000R\010binaryOp\022A\n\007if_else\030& \001(\0132&.substra"
  "it.DerivationExpression.IfElseH\000R\006ifElse"
  "\022V\n\016return_program\030\' \001(\0132-.substrait.Der"
  "ivationExpression.ReturnProgramH\000R\rretur"
  "nProgram\032\272\001\n\023ExpressionFixedChar\0227\n\006leng"
  "th\030\001 \001(\0132\037.substrait.DerivationExpressio"
  "nR\006length\022+\n\021variation_pointer\030\002 \001(\rR\020va"
  "riationPointer\022=\n\013nullability\030\003 \001(\0162\033.su"
  "bstrait.Type.NullabilityR\013nullability\032\270\001"
  "\n\021ExpressionVarChar\0227\n\006length\030\001 \001(\0132\037.su"
  "bstrait.DerivationExpressionR\006length\022+\n\021"
  "variation_pointer\030\002 \001(\rR\020variationPointe"
  "r\022=\n\013nullability\030\003 \001(\0162\033.substrait.Type."
  "NullabilityR\013nullability\032\274\001\n\025ExpressionF"
  "ixedBinary\0227\n\006length\030\001 \001(\0132\037.substrait.D"
  "erivationExpressionR\006length\022+\n\021variation"
  "_pointer\030\002 \001(\rR\020variationPointer\022=\n\013null"
  "ability\030\003 \001(\0162\033.substrait.Type.Nullabili"
  "tyR\013nullability\032\365\001\n\021ExpressionDecimal\0225\n"
  "\005scale\030\001 \001(\0132\037.substrait.DerivationExpre"
  "ssionR\005scale\022=\n\tprecision\030\002 \001(\0132\037.substr"
  "ait.DerivationExpressionR\tprecision\022+\n\021v"
  "ariation_pointer\030\003 \001(\rR\020variationPointer"
  "\022=\n\013nullability\030\004 \001(\0162\033.substrait.Type.N"
  "ullabilityR\013nullability\032\265\001\n\020ExpressionSt"
  "ruct\0225\n\005types\030\001 \003(\0132\037.substrait.Derivati"
  "onExpressionR\005types\022+\n\021variation_pointer"
  "\030\002 \001(\rR\020variationPointer\022=\n\013nullability\030"
  "\003 \001(\0162\033.substrait.Type.NullabilityR\013null"
  "ability\032w\n\025ExpressionNamedStruct\022\024\n\005name"
  "s\030\001 \003(\tR\005names\022H\n\006struct\030\002 \001(\01320.substra"
  "it.DerivationExpression.ExpressionStruct"
  "R\006struct\032\261\001\n\016ExpressionList\0223\n\004type\030\001 \001("
  "\0132\037.substrait.DerivationExpressionR\004type"
  "\022+\n\021variation_pointer\030\002 \001(\rR\020variationPo"
  "inter\022=\n\013nullability\030\003 \001(\0162\033.substrait.T"
  "ype.NullabilityR\013nullability\032\345\001\n\rExpress"
  "ionMap\0221\n\003key\030\001 \001(\0132\037.substrait.Derivati"
  "onExpressionR\003key\0225\n\005value\030\002 \001(\0132\037.subst"
  "rait.DerivationExpressionR\005value\022+\n\021vari"
  "ation_pointer\030\003 \001(\rR\020variationPointer\022=\n"
  "\013nullability\030\004 \001(\0162\033.substrait.Type.Null"
  "abilityR\013nullability\032\314\001\n\006IfElse\022B\n\014if_co"
  "ndition\030\001 \001(\0132\037.substrait.DerivationExpr"
  "essionR\013ifCondition\022<\n\tif_return\030\002 \001(\0132\037"
  ".substrait.DerivationExpressionR\010ifRetur"
  "n\022@\n\013else_return\030\003 \001(\0132\037.substrait.Deriv"
  "ationExpressionR\nelseReturn\032\327\001\n\007UnaryOp\022"
  "L\n\007op_type\030\001 \001(\01623.substrait.DerivationE"
  "xpression.UnaryOp.UnaryOpTypeR\006opType\0221\n"
  "\003arg\030\002 \001(\0132\037.substrait.DerivationExpress"
  "ionR\003arg\"K\n\013UnaryOpType\022\035\n\031UNARY_OP_TYPE"
  "_UNSPECIFIED\020\000\022\035\n\031UNARY_OP_TYPE_BOOLEAN_"
  "NOT\020\001\032\264\004\n\010BinaryOp\022N\n\007op_type\030\001 \001(\01625.su"
  "bstrait.DerivationExpression.BinaryOp.Bi"
  "naryOpTypeR\006opType\0223\n\004arg1\030\002 \001(\0132\037.subst"
  "rait.DerivationExpressionR\004arg1\0223\n\004arg2\030"
  "\003 \001(\0132\037.substrait.DerivationExpressionR\004"
  "arg2\"\355\002\n\014BinaryOpType\022\036\n\032BINARY_OP_TYPE_"
  "UNSPECIFIED\020\000\022\027\n\023BINARY_OP_TYPE_PLUS\020\001\022\030"
  "\n\024BINARY_OP_TYPE_MINUS\020\002\022\033\n\027BINARY_OP_TY"
  "PE_MULTIPLY\020\003\022\031\n\025BINARY_OP_TYPE_DIVIDE\020\004"
  "\022\026\n\022BINARY_OP_TYPE_MIN\020\005\022\026\n\022BINARY_OP_TY"
  "PE_MAX\020\006\022\037\n\033BINARY_OP_TYPE_GREATER_THAN\020"
  "\007\022\034\n\030BINARY_OP_TYPE_LESS_THAN\020\010\022\026\n\022BINAR"
  "Y_OP_TYPE_AND\020\t\022\025\n\021BINARY_OP_TYPE_OR\020\n\022\031"
  "\n\025BINARY_OP_TYPE_EQUALS\020\013\022\031\n\025BINARY_OP_T"
  "YPE_COVERS\020\014\032\232\002\n\rReturnProgram\022Z\n\013assign"
  "ments\030\001 \003(\01328.substrait.DerivationExpres"
  "sion.ReturnProgram.AssignmentR\013assignmen"
  "ts\022J\n\020final_expression\030\002 \001(\0132\037.substrait"
  ".DerivationExpressionR\017finalExpression\032a"
  "\n\nAssignment\022\022\n\004name\030\001 \001(\tR\004name\022\?\n\nexpr"
  "ession\030\002 \001(\0132\037.substrait.DerivationExpre"
  "ssionR\nexpressionB\006\n\004kindB+\n\022io.substrai"
  "t.protoP\001\252\002\022Substrait.Protobufb\006proto3"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2ftype_5fexpressions_2eproto_deps[1] = {
  &::descriptor_table_substrait_2ftype_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ftype_5fexpressions_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_5fexpressions_2eproto = {
  false, false, 4798, descriptor_table_protodef_substrait_2ftype_5fexpressions_2eproto, "substrait/type_expressions.proto", 
  &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, descriptor_table_substrait_2ftype_5fexpressions_2eproto_deps, 1, 14,
  schemas, file_default_instances, TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets,
  file_level_metadata_substrait_2ftype_5fexpressions_2eproto, file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto, file_level_service_descriptors_substrait_2ftype_5fexpressions_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter() {
  return &descriptor_table_substrait_2ftype_5fexpressions_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ftype_5fexpressions_2eproto(&descriptor_table_substrait_2ftype_5fexpressions_2eproto);
namespace substrait {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_UnaryOpType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_5fexpressions_2eproto);
  return file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[0];
}
bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_UNSPECIFIED;
constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_BOOLEAN_NOT;
constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MIN;
constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MAX;
constexpr int DerivationExpression_UnaryOp::UnaryOpType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_BinaryOpType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_5fexpressions_2eproto);
  return file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[1];
}
bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_UNSPECIFIED;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_PLUS;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MINUS;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MULTIPLY;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_DIVIDE;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MIN;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MAX;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_GREATER_THAN;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_LESS_THAN;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_AND;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_OR;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_EQUALS;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_COVERS;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MIN;
constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MAX;
constexpr int DerivationExpression_BinaryOp::BinaryOpType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class DerivationExpression_ExpressionFixedChar::_Internal {
 public:
  static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedChar* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_ExpressionFixedChar::_Internal::length(const DerivationExpression_ExpressionFixedChar* msg) {
  return *msg->length_;
}
DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedChar)
}
DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_length()) {
    length_ = new ::substrait::DerivationExpression(*from.length_);
  } else {
    length_ = nullptr;
  }
  ::memcpy(&variation_pointer_, &from.variation_pointer_,
    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedChar)
}

inline void DerivationExpression_ExpressionFixedChar::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
}

DerivationExpression_ExpressionFixedChar::~DerivationExpression_ExpressionFixedChar() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedChar)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ExpressionFixedChar::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete length_;
}

void DerivationExpression_ExpressionFixedChar::ArenaDtor(void* object) {
  DerivationExpression_ExpressionFixedChar* _this = reinterpret_cast< DerivationExpression_ExpressionFixedChar* >(object);
  (void)_this;
}
void DerivationExpression_ExpressionFixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ExpressionFixedChar::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ExpressionFixedChar::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedChar)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
    delete length_;
  }
  length_ = nullptr;
  ::memset(&variation_pointer_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&nullability_) -
      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ExpressionFixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.DerivationExpression length = 1 [json_name = "length"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_length(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint32 variation_pointer = 2 [json_name = "variationPointer"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ExpressionFixedChar::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedChar)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.DerivationExpression length = 1 [json_name = "length"];
  if (this->_internal_has_length()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::length(this), target, stream);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_nullability(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionFixedChar)
  return target;
}

size_t DerivationExpression_ExpressionFixedChar::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedChar)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .substrait.DerivationExpression length = 1 [json_name = "length"];
  if (this->_internal_has_length()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *length_);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionFixedChar::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ExpressionFixedChar::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionFixedChar::GetClassData() const { return &_class_data_; }

void DerivationExpression_ExpressionFixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ExpressionFixedChar *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ExpressionFixedChar &>(from));
}


void DerivationExpression_ExpressionFixedChar::MergeFrom(const DerivationExpression_ExpressionFixedChar& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedChar)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_length()) {
    _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length());
  }
  if (from._internal_variation_pointer() != 0) {
    _internal_set_variation_pointer(from._internal_variation_pointer());
  }
  if (from._internal_nullability() != 0) {
    _internal_set_nullability(from._internal_nullability());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ExpressionFixedChar::CopyFrom(const DerivationExpression_ExpressionFixedChar& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionFixedChar)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ExpressionFixedChar::IsInitialized() const {
  return true;
}

void DerivationExpression_ExpressionFixedChar::InternalSwap(DerivationExpression_ExpressionFixedChar* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedChar, nullability_)
      + sizeof(DerivationExpression_ExpressionFixedChar::nullability_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedChar, length_)>(
          reinterpret_cast<char*>(&length_),
          reinterpret_cast<char*>(&other->length_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedChar::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[0]);
}

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

class DerivationExpression_ExpressionVarChar::_Internal {
 public:
  static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionVarChar* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_ExpressionVarChar::_Internal::length(const DerivationExpression_ExpressionVarChar* msg) {
  return *msg->length_;
}
DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionVarChar)
}
DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_length()) {
    length_ = new ::substrait::DerivationExpression(*from.length_);
  } else {
    length_ = nullptr;
  }
  ::memcpy(&variation_pointer_, &from.variation_pointer_,
    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionVarChar)
}

inline void DerivationExpression_ExpressionVarChar::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
}

DerivationExpression_ExpressionVarChar::~DerivationExpression_ExpressionVarChar() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionVarChar)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ExpressionVarChar::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete length_;
}

void DerivationExpression_ExpressionVarChar::ArenaDtor(void* object) {
  DerivationExpression_ExpressionVarChar* _this = reinterpret_cast< DerivationExpression_ExpressionVarChar* >(object);
  (void)_this;
}
void DerivationExpression_ExpressionVarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ExpressionVarChar::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ExpressionVarChar::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionVarChar)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
    delete length_;
  }
  length_ = nullptr;
  ::memset(&variation_pointer_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&nullability_) -
      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ExpressionVarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.DerivationExpression length = 1 [json_name = "length"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_length(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint32 variation_pointer = 2 [json_name = "variationPointer"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ExpressionVarChar::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionVarChar)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.DerivationExpression length = 1 [json_name = "length"];
  if (this->_internal_has_length()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::length(this), target, stream);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_nullability(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionVarChar)
  return target;
}

size_t DerivationExpression_ExpressionVarChar::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionVarChar)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .substrait.DerivationExpression length = 1 [json_name = "length"];
  if (this->_internal_has_length()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *length_);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionVarChar::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ExpressionVarChar::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionVarChar::GetClassData() const { return &_class_data_; }

void DerivationExpression_ExpressionVarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ExpressionVarChar *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ExpressionVarChar &>(from));
}


void DerivationExpression_ExpressionVarChar::MergeFrom(const DerivationExpression_ExpressionVarChar& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionVarChar)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_length()) {
    _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length());
  }
  if (from._internal_variation_pointer() != 0) {
    _internal_set_variation_pointer(from._internal_variation_pointer());
  }
  if (from._internal_nullability() != 0) {
    _internal_set_nullability(from._internal_nullability());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ExpressionVarChar::CopyFrom(const DerivationExpression_ExpressionVarChar& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionVarChar)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ExpressionVarChar::IsInitialized() const {
  return true;
}

void DerivationExpression_ExpressionVarChar::InternalSwap(DerivationExpression_ExpressionVarChar* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionVarChar, nullability_)
      + sizeof(DerivationExpression_ExpressionVarChar::nullability_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionVarChar, length_)>(
          reinterpret_cast<char*>(&length_),
          reinterpret_cast<char*>(&other->length_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionVarChar::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[1]);
}

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

class DerivationExpression_ExpressionFixedBinary::_Internal {
 public:
  static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedBinary* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_ExpressionFixedBinary::_Internal::length(const DerivationExpression_ExpressionFixedBinary* msg) {
  return *msg->length_;
}
DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedBinary)
}
DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_length()) {
    length_ = new ::substrait::DerivationExpression(*from.length_);
  } else {
    length_ = nullptr;
  }
  ::memcpy(&variation_pointer_, &from.variation_pointer_,
    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedBinary)
}

inline void DerivationExpression_ExpressionFixedBinary::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
}

DerivationExpression_ExpressionFixedBinary::~DerivationExpression_ExpressionFixedBinary() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedBinary)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ExpressionFixedBinary::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete length_;
}

void DerivationExpression_ExpressionFixedBinary::ArenaDtor(void* object) {
  DerivationExpression_ExpressionFixedBinary* _this = reinterpret_cast< DerivationExpression_ExpressionFixedBinary* >(object);
  (void)_this;
}
void DerivationExpression_ExpressionFixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ExpressionFixedBinary::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ExpressionFixedBinary::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedBinary)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
    delete length_;
  }
  length_ = nullptr;
  ::memset(&variation_pointer_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&nullability_) -
      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ExpressionFixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.DerivationExpression length = 1 [json_name = "length"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_length(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint32 variation_pointer = 2 [json_name = "variationPointer"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ExpressionFixedBinary::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedBinary)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.DerivationExpression length = 1 [json_name = "length"];
  if (this->_internal_has_length()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::length(this), target, stream);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_nullability(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionFixedBinary)
  return target;
}

size_t DerivationExpression_ExpressionFixedBinary::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedBinary)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .substrait.DerivationExpression length = 1 [json_name = "length"];
  if (this->_internal_has_length()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *length_);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionFixedBinary::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ExpressionFixedBinary::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionFixedBinary::GetClassData() const { return &_class_data_; }

void DerivationExpression_ExpressionFixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ExpressionFixedBinary *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ExpressionFixedBinary &>(from));
}


void DerivationExpression_ExpressionFixedBinary::MergeFrom(const DerivationExpression_ExpressionFixedBinary& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedBinary)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_length()) {
    _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length());
  }
  if (from._internal_variation_pointer() != 0) {
    _internal_set_variation_pointer(from._internal_variation_pointer());
  }
  if (from._internal_nullability() != 0) {
    _internal_set_nullability(from._internal_nullability());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ExpressionFixedBinary::CopyFrom(const DerivationExpression_ExpressionFixedBinary& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionFixedBinary)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ExpressionFixedBinary::IsInitialized() const {
  return true;
}

void DerivationExpression_ExpressionFixedBinary::InternalSwap(DerivationExpression_ExpressionFixedBinary* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedBinary, nullability_)
      + sizeof(DerivationExpression_ExpressionFixedBinary::nullability_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedBinary, length_)>(
          reinterpret_cast<char*>(&length_),
          reinterpret_cast<char*>(&other->length_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedBinary::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[2]);
}

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

class DerivationExpression_ExpressionDecimal::_Internal {
 public:
  static const ::substrait::DerivationExpression& scale(const DerivationExpression_ExpressionDecimal* msg);
  static const ::substrait::DerivationExpression& precision(const DerivationExpression_ExpressionDecimal* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_ExpressionDecimal::_Internal::scale(const DerivationExpression_ExpressionDecimal* msg) {
  return *msg->scale_;
}
const ::substrait::DerivationExpression&
DerivationExpression_ExpressionDecimal::_Internal::precision(const DerivationExpression_ExpressionDecimal* msg) {
  return *msg->precision_;
}
DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionDecimal)
}
DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_scale()) {
    scale_ = new ::substrait::DerivationExpression(*from.scale_);
  } else {
    scale_ = nullptr;
  }
  if (from._internal_has_precision()) {
    precision_ = new ::substrait::DerivationExpression(*from.precision_);
  } else {
    precision_ = nullptr;
  }
  ::memcpy(&variation_pointer_, &from.variation_pointer_,
    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionDecimal)
}

inline void DerivationExpression_ExpressionDecimal::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&scale_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&scale_)) + sizeof(nullability_));
}

DerivationExpression_ExpressionDecimal::~DerivationExpression_ExpressionDecimal() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionDecimal)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ExpressionDecimal::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete scale_;
  if (this != internal_default_instance()) delete precision_;
}

void DerivationExpression_ExpressionDecimal::ArenaDtor(void* object) {
  DerivationExpression_ExpressionDecimal* _this = reinterpret_cast< DerivationExpression_ExpressionDecimal* >(object);
  (void)_this;
}
void DerivationExpression_ExpressionDecimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ExpressionDecimal::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ExpressionDecimal::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionDecimal)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && scale_ != nullptr) {
    delete scale_;
  }
  scale_ = nullptr;
  if (GetArenaForAllocation() == nullptr && precision_ != nullptr) {
    delete precision_;
  }
  precision_ = nullptr;
  ::memset(&variation_pointer_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&nullability_) -
      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ExpressionDecimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.DerivationExpression scale = 1 [json_name = "scale"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression precision = 2 [json_name = "precision"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint32 variation_pointer = 3 [json_name = "variationPointer"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ExpressionDecimal::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionDecimal)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.DerivationExpression scale = 1 [json_name = "scale"];
  if (this->_internal_has_scale()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::scale(this), target, stream);
  }

  // .substrait.DerivationExpression precision = 2 [json_name = "precision"];
  if (this->_internal_has_precision()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::precision(this), target, stream);
  }

  // uint32 variation_pointer = 3 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target);
  }

  // .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_nullability(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionDecimal)
  return target;
}

size_t DerivationExpression_ExpressionDecimal::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionDecimal)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .substrait.DerivationExpression scale = 1 [json_name = "scale"];
  if (this->_internal_has_scale()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *scale_);
  }

  // .substrait.DerivationExpression precision = 2 [json_name = "precision"];
  if (this->_internal_has_precision()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *precision_);
  }

  // uint32 variation_pointer = 3 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
  }

  // .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionDecimal::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ExpressionDecimal::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionDecimal::GetClassData() const { return &_class_data_; }

void DerivationExpression_ExpressionDecimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ExpressionDecimal *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ExpressionDecimal &>(from));
}


void DerivationExpression_ExpressionDecimal::MergeFrom(const DerivationExpression_ExpressionDecimal& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionDecimal)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_scale()) {
    _internal_mutable_scale()->::substrait::DerivationExpression::MergeFrom(from._internal_scale());
  }
  if (from._internal_has_precision()) {
    _internal_mutable_precision()->::substrait::DerivationExpression::MergeFrom(from._internal_precision());
  }
  if (from._internal_variation_pointer() != 0) {
    _internal_set_variation_pointer(from._internal_variation_pointer());
  }
  if (from._internal_nullability() != 0) {
    _internal_set_nullability(from._internal_nullability());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ExpressionDecimal::CopyFrom(const DerivationExpression_ExpressionDecimal& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionDecimal)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ExpressionDecimal::IsInitialized() const {
  return true;
}

void DerivationExpression_ExpressionDecimal::InternalSwap(DerivationExpression_ExpressionDecimal* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionDecimal, nullability_)
      + sizeof(DerivationExpression_ExpressionDecimal::nullability_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionDecimal, scale_)>(
          reinterpret_cast<char*>(&scale_),
          reinterpret_cast<char*>(&other->scale_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionDecimal::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[3]);
}

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

class DerivationExpression_ExpressionStruct::_Internal {
 public:
};

DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  types_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionStruct)
}
DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      types_(from.types_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&variation_pointer_, &from.variation_pointer_,
    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionStruct)
}

inline void DerivationExpression_ExpressionStruct::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&variation_pointer_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
}

DerivationExpression_ExpressionStruct::~DerivationExpression_ExpressionStruct() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionStruct)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ExpressionStruct::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void DerivationExpression_ExpressionStruct::ArenaDtor(void* object) {
  DerivationExpression_ExpressionStruct* _this = reinterpret_cast< DerivationExpression_ExpressionStruct* >(object);
  (void)_this;
}
void DerivationExpression_ExpressionStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ExpressionStruct::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ExpressionStruct::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionStruct)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  types_.Clear();
  ::memset(&variation_pointer_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&nullability_) -
      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .substrait.DerivationExpression types = 1 [json_name = "types"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_types(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // uint32 variation_pointer = 2 [json_name = "variationPointer"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ExpressionStruct::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionStruct)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.DerivationExpression types = 1 [json_name = "types"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_types_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_types(i), target, stream);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_nullability(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionStruct)
  return target;
}

size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionStruct)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .substrait.DerivationExpression types = 1 [json_name = "types"];
  total_size += 1UL * this->_internal_types_size();
  for (const auto& msg : this->types_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionStruct::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ExpressionStruct::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionStruct::GetClassData() const { return &_class_data_; }

void DerivationExpression_ExpressionStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ExpressionStruct *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ExpressionStruct &>(from));
}


void DerivationExpression_ExpressionStruct::MergeFrom(const DerivationExpression_ExpressionStruct& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionStruct)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  types_.MergeFrom(from.types_);
  if (from._internal_variation_pointer() != 0) {
    _internal_set_variation_pointer(from._internal_variation_pointer());
  }
  if (from._internal_nullability() != 0) {
    _internal_set_nullability(from._internal_nullability());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ExpressionStruct::CopyFrom(const DerivationExpression_ExpressionStruct& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionStruct)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ExpressionStruct::IsInitialized() const {
  return true;
}

void DerivationExpression_ExpressionStruct::InternalSwap(DerivationExpression_ExpressionStruct* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  types_.InternalSwap(&other->types_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, nullability_)
      + sizeof(DerivationExpression_ExpressionStruct::nullability_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, variation_pointer_)>(
          reinterpret_cast<char*>(&variation_pointer_),
          reinterpret_cast<char*>(&other->variation_pointer_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionStruct::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[4]);
}

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

class DerivationExpression_ExpressionNamedStruct::_Internal {
 public:
  static const ::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression_ExpressionNamedStruct* msg);
};

const ::substrait::DerivationExpression_ExpressionStruct&
DerivationExpression_ExpressionNamedStruct::_Internal::struct_(const DerivationExpression_ExpressionNamedStruct* msg) {
  return *msg->struct__;
}
DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  names_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionNamedStruct)
}
DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      names_(from.names_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_struct_()) {
    struct__ = new ::substrait::DerivationExpression_ExpressionStruct(*from.struct__);
  } else {
    struct__ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionNamedStruct)
}

inline void DerivationExpression_ExpressionNamedStruct::SharedCtor() {
struct__ = nullptr;
}

DerivationExpression_ExpressionNamedStruct::~DerivationExpression_ExpressionNamedStruct() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionNamedStruct)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ExpressionNamedStruct::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete struct__;
}

void DerivationExpression_ExpressionNamedStruct::ArenaDtor(void* object) {
  DerivationExpression_ExpressionNamedStruct* _this = reinterpret_cast< DerivationExpression_ExpressionNamedStruct* >(object);
  (void)_this;
}
void DerivationExpression_ExpressionNamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ExpressionNamedStruct::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ExpressionNamedStruct::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionNamedStruct)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  names_.Clear();
  if (GetArenaForAllocation() == nullptr && struct__ != nullptr) {
    delete struct__;
  }
  struct__ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ExpressionNamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated string names = 1 [json_name = "names"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_names();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.ExpressionNamedStruct.names"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.ExpressionStruct struct = 2 [json_name = "struct"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ExpressionNamedStruct::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionNamedStruct)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string names = 1 [json_name = "names"];
  for (int i = 0, n = this->_internal_names_size(); i < n; i++) {
    const auto& s = this->_internal_names(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.DerivationExpression.ExpressionNamedStruct.names");
    target = stream->WriteString(1, s, target);
  }

  // .substrait.DerivationExpression.ExpressionStruct struct = 2 [json_name = "struct"];
  if (this->_internal_has_struct_()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::struct_(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionNamedStruct)
  return target;
}

size_t DerivationExpression_ExpressionNamedStruct::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionNamedStruct)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string names = 1 [json_name = "names"];
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size());
  for (int i = 0, n = names_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      names_.Get(i));
  }

  // .substrait.DerivationExpression.ExpressionStruct struct = 2 [json_name = "struct"];
  if (this->_internal_has_struct_()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *struct__);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionNamedStruct::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ExpressionNamedStruct::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionNamedStruct::GetClassData() const { return &_class_data_; }

void DerivationExpression_ExpressionNamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ExpressionNamedStruct *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ExpressionNamedStruct &>(from));
}


void DerivationExpression_ExpressionNamedStruct::MergeFrom(const DerivationExpression_ExpressionNamedStruct& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionNamedStruct)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  names_.MergeFrom(from.names_);
  if (from._internal_has_struct_()) {
    _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ExpressionNamedStruct::CopyFrom(const DerivationExpression_ExpressionNamedStruct& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionNamedStruct)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ExpressionNamedStruct::IsInitialized() const {
  return true;
}

void DerivationExpression_ExpressionNamedStruct::InternalSwap(DerivationExpression_ExpressionNamedStruct* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  names_.InternalSwap(&other->names_);
  swap(struct__, other->struct__);
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionNamedStruct::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[5]);
}

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

class DerivationExpression_ExpressionList::_Internal {
 public:
  static const ::substrait::DerivationExpression& type(const DerivationExpression_ExpressionList* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_ExpressionList::_Internal::type(const DerivationExpression_ExpressionList* msg) {
  return *msg->type_;
}
DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionList)
}
DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_type()) {
    type_ = new ::substrait::DerivationExpression(*from.type_);
  } else {
    type_ = nullptr;
  }
  ::memcpy(&variation_pointer_, &from.variation_pointer_,
    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionList)
}

inline void DerivationExpression_ExpressionList::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&type_)) + sizeof(nullability_));
}

DerivationExpression_ExpressionList::~DerivationExpression_ExpressionList() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionList)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ExpressionList::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete type_;
}

void DerivationExpression_ExpressionList::ArenaDtor(void* object) {
  DerivationExpression_ExpressionList* _this = reinterpret_cast< DerivationExpression_ExpressionList* >(object);
  (void)_this;
}
void DerivationExpression_ExpressionList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ExpressionList::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ExpressionList::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionList)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
    delete type_;
  }
  type_ = nullptr;
  ::memset(&variation_pointer_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&nullability_) -
      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ExpressionList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.DerivationExpression type = 1 [json_name = "type"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint32 variation_pointer = 2 [json_name = "variationPointer"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ExpressionList::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionList)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.DerivationExpression type = 1 [json_name = "type"];
  if (this->_internal_has_type()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::type(this), target, stream);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_nullability(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionList)
  return target;
}

size_t DerivationExpression_ExpressionList::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionList)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .substrait.DerivationExpression type = 1 [json_name = "type"];
  if (this->_internal_has_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *type_);
  }

  // uint32 variation_pointer = 2 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
  }

  // .substrait.Type.Nullability nullability = 3 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionList::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ExpressionList::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionList::GetClassData() const { return &_class_data_; }

void DerivationExpression_ExpressionList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ExpressionList *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ExpressionList &>(from));
}


void DerivationExpression_ExpressionList::MergeFrom(const DerivationExpression_ExpressionList& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionList)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_type()) {
    _internal_mutable_type()->::substrait::DerivationExpression::MergeFrom(from._internal_type());
  }
  if (from._internal_variation_pointer() != 0) {
    _internal_set_variation_pointer(from._internal_variation_pointer());
  }
  if (from._internal_nullability() != 0) {
    _internal_set_nullability(from._internal_nullability());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ExpressionList::CopyFrom(const DerivationExpression_ExpressionList& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionList)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ExpressionList::IsInitialized() const {
  return true;
}

void DerivationExpression_ExpressionList::InternalSwap(DerivationExpression_ExpressionList* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionList, nullability_)
      + sizeof(DerivationExpression_ExpressionList::nullability_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionList, type_)>(
          reinterpret_cast<char*>(&type_),
          reinterpret_cast<char*>(&other->type_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionList::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[6]);
}

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

class DerivationExpression_ExpressionMap::_Internal {
 public:
  static const ::substrait::DerivationExpression& key(const DerivationExpression_ExpressionMap* msg);
  static const ::substrait::DerivationExpression& value(const DerivationExpression_ExpressionMap* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_ExpressionMap::_Internal::key(const DerivationExpression_ExpressionMap* msg) {
  return *msg->key_;
}
const ::substrait::DerivationExpression&
DerivationExpression_ExpressionMap::_Internal::value(const DerivationExpression_ExpressionMap* msg) {
  return *msg->value_;
}
DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionMap)
}
DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_key()) {
    key_ = new ::substrait::DerivationExpression(*from.key_);
  } else {
    key_ = nullptr;
  }
  if (from._internal_has_value()) {
    value_ = new ::substrait::DerivationExpression(*from.value_);
  } else {
    value_ = nullptr;
  }
  ::memcpy(&variation_pointer_, &from.variation_pointer_,
    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionMap)
}

inline void DerivationExpression_ExpressionMap::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&key_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
    reinterpret_cast<char*>(&key_)) + sizeof(nullability_));
}

DerivationExpression_ExpressionMap::~DerivationExpression_ExpressionMap() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionMap)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ExpressionMap::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete key_;
  if (this != internal_default_instance()) delete value_;
}

void DerivationExpression_ExpressionMap::ArenaDtor(void* object) {
  DerivationExpression_ExpressionMap* _this = reinterpret_cast< DerivationExpression_ExpressionMap* >(object);
  (void)_this;
}
void DerivationExpression_ExpressionMap::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ExpressionMap::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ExpressionMap::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionMap)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
    delete key_;
  }
  key_ = nullptr;
  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
    delete value_;
  }
  value_ = nullptr;
  ::memset(&variation_pointer_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&nullability_) -
      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ExpressionMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.DerivationExpression key = 1 [json_name = "key"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression value = 2 [json_name = "value"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint32 variation_pointer = 3 [json_name = "variationPointer"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ExpressionMap::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionMap)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.DerivationExpression key = 1 [json_name = "key"];
  if (this->_internal_has_key()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::key(this), target, stream);
  }

  // .substrait.DerivationExpression value = 2 [json_name = "value"];
  if (this->_internal_has_value()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::value(this), target, stream);
  }

  // uint32 variation_pointer = 3 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target);
  }

  // .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_nullability(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionMap)
  return target;
}

size_t DerivationExpression_ExpressionMap::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionMap)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .substrait.DerivationExpression key = 1 [json_name = "key"];
  if (this->_internal_has_key()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *key_);
  }

  // .substrait.DerivationExpression value = 2 [json_name = "value"];
  if (this->_internal_has_value()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *value_);
  }

  // uint32 variation_pointer = 3 [json_name = "variationPointer"];
  if (this->_internal_variation_pointer() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
  }

  // .substrait.Type.Nullability nullability = 4 [json_name = "nullability"];
  if (this->_internal_nullability() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionMap::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ExpressionMap::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionMap::GetClassData() const { return &_class_data_; }

void DerivationExpression_ExpressionMap::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ExpressionMap *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ExpressionMap &>(from));
}


void DerivationExpression_ExpressionMap::MergeFrom(const DerivationExpression_ExpressionMap& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionMap)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_key()) {
    _internal_mutable_key()->::substrait::DerivationExpression::MergeFrom(from._internal_key());
  }
  if (from._internal_has_value()) {
    _internal_mutable_value()->::substrait::DerivationExpression::MergeFrom(from._internal_value());
  }
  if (from._internal_variation_pointer() != 0) {
    _internal_set_variation_pointer(from._internal_variation_pointer());
  }
  if (from._internal_nullability() != 0) {
    _internal_set_nullability(from._internal_nullability());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ExpressionMap::CopyFrom(const DerivationExpression_ExpressionMap& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionMap)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ExpressionMap::IsInitialized() const {
  return true;
}

void DerivationExpression_ExpressionMap::InternalSwap(DerivationExpression_ExpressionMap* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionMap, nullability_)
      + sizeof(DerivationExpression_ExpressionMap::nullability_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionMap, key_)>(
          reinterpret_cast<char*>(&key_),
          reinterpret_cast<char*>(&other->key_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionMap::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[7]);
}

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

class DerivationExpression_IfElse::_Internal {
 public:
  static const ::substrait::DerivationExpression& if_condition(const DerivationExpression_IfElse* msg);
  static const ::substrait::DerivationExpression& if_return(const DerivationExpression_IfElse* msg);
  static const ::substrait::DerivationExpression& else_return(const DerivationExpression_IfElse* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_IfElse::_Internal::if_condition(const DerivationExpression_IfElse* msg) {
  return *msg->if_condition_;
}
const ::substrait::DerivationExpression&
DerivationExpression_IfElse::_Internal::if_return(const DerivationExpression_IfElse* msg) {
  return *msg->if_return_;
}
const ::substrait::DerivationExpression&
DerivationExpression_IfElse::_Internal::else_return(const DerivationExpression_IfElse* msg) {
  return *msg->else_return_;
}
DerivationExpression_IfElse::DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.IfElse)
}
DerivationExpression_IfElse::DerivationExpression_IfElse(const DerivationExpression_IfElse& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_if_condition()) {
    if_condition_ = new ::substrait::DerivationExpression(*from.if_condition_);
  } else {
    if_condition_ = nullptr;
  }
  if (from._internal_has_if_return()) {
    if_return_ = new ::substrait::DerivationExpression(*from.if_return_);
  } else {
    if_return_ = nullptr;
  }
  if (from._internal_has_else_return()) {
    else_return_ = new ::substrait::DerivationExpression(*from.else_return_);
  } else {
    else_return_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.IfElse)
}

inline void DerivationExpression_IfElse::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&if_condition_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&else_return_) -
    reinterpret_cast<char*>(&if_condition_)) + sizeof(else_return_));
}

DerivationExpression_IfElse::~DerivationExpression_IfElse() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.IfElse)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_IfElse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete if_condition_;
  if (this != internal_default_instance()) delete if_return_;
  if (this != internal_default_instance()) delete else_return_;
}

void DerivationExpression_IfElse::ArenaDtor(void* object) {
  DerivationExpression_IfElse* _this = reinterpret_cast< DerivationExpression_IfElse* >(object);
  (void)_this;
}
void DerivationExpression_IfElse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_IfElse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_IfElse::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.IfElse)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && if_condition_ != nullptr) {
    delete if_condition_;
  }
  if_condition_ = nullptr;
  if (GetArenaForAllocation() == nullptr && if_return_ != nullptr) {
    delete if_return_;
  }
  if_return_ = nullptr;
  if (GetArenaForAllocation() == nullptr && else_return_ != nullptr) {
    delete else_return_;
  }
  else_return_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_IfElse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.DerivationExpression if_condition = 1 [json_name = "ifCondition"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_if_condition(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression if_return = 2 [json_name = "ifReturn"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_if_return(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression else_return = 3 [json_name = "elseReturn"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_else_return(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_IfElse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.IfElse)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.DerivationExpression if_condition = 1 [json_name = "ifCondition"];
  if (this->_internal_has_if_condition()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::if_condition(this), target, stream);
  }

  // .substrait.DerivationExpression if_return = 2 [json_name = "ifReturn"];
  if (this->_internal_has_if_return()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::if_return(this), target, stream);
  }

  // .substrait.DerivationExpression else_return = 3 [json_name = "elseReturn"];
  if (this->_internal_has_else_return()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::else_return(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.IfElse)
  return target;
}

size_t DerivationExpression_IfElse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.IfElse)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .substrait.DerivationExpression if_condition = 1 [json_name = "ifCondition"];
  if (this->_internal_has_if_condition()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *if_condition_);
  }

  // .substrait.DerivationExpression if_return = 2 [json_name = "ifReturn"];
  if (this->_internal_has_if_return()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *if_return_);
  }

  // .substrait.DerivationExpression else_return = 3 [json_name = "elseReturn"];
  if (this->_internal_has_else_return()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *else_return_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_IfElse::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_IfElse::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_IfElse::GetClassData() const { return &_class_data_; }

void DerivationExpression_IfElse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_IfElse *>(to)->MergeFrom(
      static_cast<const DerivationExpression_IfElse &>(from));
}


void DerivationExpression_IfElse::MergeFrom(const DerivationExpression_IfElse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.IfElse)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_if_condition()) {
    _internal_mutable_if_condition()->::substrait::DerivationExpression::MergeFrom(from._internal_if_condition());
  }
  if (from._internal_has_if_return()) {
    _internal_mutable_if_return()->::substrait::DerivationExpression::MergeFrom(from._internal_if_return());
  }
  if (from._internal_has_else_return()) {
    _internal_mutable_else_return()->::substrait::DerivationExpression::MergeFrom(from._internal_else_return());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_IfElse::CopyFrom(const DerivationExpression_IfElse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.IfElse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_IfElse::IsInitialized() const {
  return true;
}

void DerivationExpression_IfElse::InternalSwap(DerivationExpression_IfElse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_IfElse, else_return_)
      + sizeof(DerivationExpression_IfElse::else_return_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_IfElse, if_condition_)>(
          reinterpret_cast<char*>(&if_condition_),
          reinterpret_cast<char*>(&other->if_condition_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_IfElse::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[8]);
}

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

class DerivationExpression_UnaryOp::_Internal {
 public:
  static const ::substrait::DerivationExpression& arg(const DerivationExpression_UnaryOp* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_UnaryOp::_Internal::arg(const DerivationExpression_UnaryOp* msg) {
  return *msg->arg_;
}
DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.UnaryOp)
}
DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_arg()) {
    arg_ = new ::substrait::DerivationExpression(*from.arg_);
  } else {
    arg_ = nullptr;
  }
  op_type_ = from.op_type_;
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.UnaryOp)
}

inline void DerivationExpression_UnaryOp::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&arg_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&op_type_) -
    reinterpret_cast<char*>(&arg_)) + sizeof(op_type_));
}

DerivationExpression_UnaryOp::~DerivationExpression_UnaryOp() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.UnaryOp)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_UnaryOp::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete arg_;
}

void DerivationExpression_UnaryOp::ArenaDtor(void* object) {
  DerivationExpression_UnaryOp* _this = reinterpret_cast< DerivationExpression_UnaryOp* >(object);
  (void)_this;
}
void DerivationExpression_UnaryOp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_UnaryOp::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_UnaryOp::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.UnaryOp)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && arg_ != nullptr) {
    delete arg_;
  }
  arg_ = nullptr;
  op_type_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_UnaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1 [json_name = "opType"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_op_type(static_cast<::substrait::DerivationExpression_UnaryOp_UnaryOpType>(val));
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression arg = 2 [json_name = "arg"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_arg(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_UnaryOp::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.UnaryOp)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1 [json_name = "opType"];
  if (this->_internal_op_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_op_type(), target);
  }

  // .substrait.DerivationExpression arg = 2 [json_name = "arg"];
  if (this->_internal_has_arg()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::arg(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.UnaryOp)
  return target;
}

size_t DerivationExpression_UnaryOp::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.UnaryOp)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .substrait.DerivationExpression arg = 2 [json_name = "arg"];
  if (this->_internal_has_arg()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *arg_);
  }

  // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1 [json_name = "opType"];
  if (this->_internal_op_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_UnaryOp::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_UnaryOp::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_UnaryOp::GetClassData() const { return &_class_data_; }

void DerivationExpression_UnaryOp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_UnaryOp *>(to)->MergeFrom(
      static_cast<const DerivationExpression_UnaryOp &>(from));
}


void DerivationExpression_UnaryOp::MergeFrom(const DerivationExpression_UnaryOp& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.UnaryOp)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_arg()) {
    _internal_mutable_arg()->::substrait::DerivationExpression::MergeFrom(from._internal_arg());
  }
  if (from._internal_op_type() != 0) {
    _internal_set_op_type(from._internal_op_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_UnaryOp::CopyFrom(const DerivationExpression_UnaryOp& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.UnaryOp)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_UnaryOp::IsInitialized() const {
  return true;
}

void DerivationExpression_UnaryOp::InternalSwap(DerivationExpression_UnaryOp* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_UnaryOp, op_type_)
      + sizeof(DerivationExpression_UnaryOp::op_type_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_UnaryOp, arg_)>(
          reinterpret_cast<char*>(&arg_),
          reinterpret_cast<char*>(&other->arg_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_UnaryOp::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[9]);
}

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

class DerivationExpression_BinaryOp::_Internal {
 public:
  static const ::substrait::DerivationExpression& arg1(const DerivationExpression_BinaryOp* msg);
  static const ::substrait::DerivationExpression& arg2(const DerivationExpression_BinaryOp* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_BinaryOp::_Internal::arg1(const DerivationExpression_BinaryOp* msg) {
  return *msg->arg1_;
}
const ::substrait::DerivationExpression&
DerivationExpression_BinaryOp::_Internal::arg2(const DerivationExpression_BinaryOp* msg) {
  return *msg->arg2_;
}
DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.BinaryOp)
}
DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_arg1()) {
    arg1_ = new ::substrait::DerivationExpression(*from.arg1_);
  } else {
    arg1_ = nullptr;
  }
  if (from._internal_has_arg2()) {
    arg2_ = new ::substrait::DerivationExpression(*from.arg2_);
  } else {
    arg2_ = nullptr;
  }
  op_type_ = from.op_type_;
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.BinaryOp)
}

inline void DerivationExpression_BinaryOp::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&arg1_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&op_type_) -
    reinterpret_cast<char*>(&arg1_)) + sizeof(op_type_));
}

DerivationExpression_BinaryOp::~DerivationExpression_BinaryOp() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.BinaryOp)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_BinaryOp::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete arg1_;
  if (this != internal_default_instance()) delete arg2_;
}

void DerivationExpression_BinaryOp::ArenaDtor(void* object) {
  DerivationExpression_BinaryOp* _this = reinterpret_cast< DerivationExpression_BinaryOp* >(object);
  (void)_this;
}
void DerivationExpression_BinaryOp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_BinaryOp::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_BinaryOp::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.BinaryOp)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && arg1_ != nullptr) {
    delete arg1_;
  }
  arg1_ = nullptr;
  if (GetArenaForAllocation() == nullptr && arg2_ != nullptr) {
    delete arg2_;
  }
  arg2_ = nullptr;
  op_type_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_BinaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1 [json_name = "opType"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_op_type(static_cast<::substrait::DerivationExpression_BinaryOp_BinaryOpType>(val));
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression arg1 = 2 [json_name = "arg1"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_arg1(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression arg2 = 3 [json_name = "arg2"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_arg2(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_BinaryOp::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.BinaryOp)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1 [json_name = "opType"];
  if (this->_internal_op_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_op_type(), target);
  }

  // .substrait.DerivationExpression arg1 = 2 [json_name = "arg1"];
  if (this->_internal_has_arg1()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::arg1(this), target, stream);
  }

  // .substrait.DerivationExpression arg2 = 3 [json_name = "arg2"];
  if (this->_internal_has_arg2()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::arg2(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.BinaryOp)
  return target;
}

size_t DerivationExpression_BinaryOp::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.BinaryOp)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .substrait.DerivationExpression arg1 = 2 [json_name = "arg1"];
  if (this->_internal_has_arg1()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *arg1_);
  }

  // .substrait.DerivationExpression arg2 = 3 [json_name = "arg2"];
  if (this->_internal_has_arg2()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *arg2_);
  }

  // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1 [json_name = "opType"];
  if (this->_internal_op_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_BinaryOp::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_BinaryOp::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_BinaryOp::GetClassData() const { return &_class_data_; }

void DerivationExpression_BinaryOp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_BinaryOp *>(to)->MergeFrom(
      static_cast<const DerivationExpression_BinaryOp &>(from));
}


void DerivationExpression_BinaryOp::MergeFrom(const DerivationExpression_BinaryOp& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.BinaryOp)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_arg1()) {
    _internal_mutable_arg1()->::substrait::DerivationExpression::MergeFrom(from._internal_arg1());
  }
  if (from._internal_has_arg2()) {
    _internal_mutable_arg2()->::substrait::DerivationExpression::MergeFrom(from._internal_arg2());
  }
  if (from._internal_op_type() != 0) {
    _internal_set_op_type(from._internal_op_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_BinaryOp::CopyFrom(const DerivationExpression_BinaryOp& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.BinaryOp)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_BinaryOp::IsInitialized() const {
  return true;
}

void DerivationExpression_BinaryOp::InternalSwap(DerivationExpression_BinaryOp* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DerivationExpression_BinaryOp, op_type_)
      + sizeof(DerivationExpression_BinaryOp::op_type_)
      - PROTOBUF_FIELD_OFFSET(DerivationExpression_BinaryOp, arg1_)>(
          reinterpret_cast<char*>(&arg1_),
          reinterpret_cast<char*>(&other->arg1_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_BinaryOp::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[10]);
}

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

class DerivationExpression_ReturnProgram_Assignment::_Internal {
 public:
  static const ::substrait::DerivationExpression& expression(const DerivationExpression_ReturnProgram_Assignment* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_ReturnProgram_Assignment::_Internal::expression(const DerivationExpression_ReturnProgram_Assignment* msg) {
  return *msg->expression_;
}
DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram.Assignment)
}
DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_name().empty()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_expression()) {
    expression_ = new ::substrait::DerivationExpression(*from.expression_);
  } else {
    expression_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram.Assignment)
}

inline void DerivationExpression_ReturnProgram_Assignment::SharedCtor() {
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
expression_ = nullptr;
}

DerivationExpression_ReturnProgram_Assignment::~DerivationExpression_ReturnProgram_Assignment() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram.Assignment)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ReturnProgram_Assignment::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete expression_;
}

void DerivationExpression_ReturnProgram_Assignment::ArenaDtor(void* object) {
  DerivationExpression_ReturnProgram_Assignment* _this = reinterpret_cast< DerivationExpression_ReturnProgram_Assignment* >(object);
  (void)_this;
}
void DerivationExpression_ReturnProgram_Assignment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ReturnProgram_Assignment::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ReturnProgram_Assignment::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram.Assignment)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  name_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && expression_ != nullptr) {
    delete expression_;
  }
  expression_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ReturnProgram_Assignment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string name = 1 [json_name = "name"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.ReturnProgram.Assignment.name"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression expression = 2 [json_name = "expression"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ReturnProgram_Assignment::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram.Assignment)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string name = 1 [json_name = "name"];
  if (!this->_internal_name().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.DerivationExpression.ReturnProgram.Assignment.name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_name(), target);
  }

  // .substrait.DerivationExpression expression = 2 [json_name = "expression"];
  if (this->_internal_has_expression()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::expression(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ReturnProgram.Assignment)
  return target;
}

size_t DerivationExpression_ReturnProgram_Assignment::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram.Assignment)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string name = 1 [json_name = "name"];
  if (!this->_internal_name().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_name());
  }

  // .substrait.DerivationExpression expression = 2 [json_name = "expression"];
  if (this->_internal_has_expression()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *expression_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ReturnProgram_Assignment::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ReturnProgram_Assignment::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ReturnProgram_Assignment::GetClassData() const { return &_class_data_; }

void DerivationExpression_ReturnProgram_Assignment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ReturnProgram_Assignment *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ReturnProgram_Assignment &>(from));
}


void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram.Assignment)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_name().empty()) {
    _internal_set_name(from._internal_name());
  }
  if (from._internal_has_expression()) {
    _internal_mutable_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_expression());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ReturnProgram_Assignment::CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ReturnProgram.Assignment)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ReturnProgram_Assignment::IsInitialized() const {
  return true;
}

void DerivationExpression_ReturnProgram_Assignment::InternalSwap(DerivationExpression_ReturnProgram_Assignment* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &name_, lhs_arena,
      &other->name_, rhs_arena
  );
  swap(expression_, other->expression_);
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram_Assignment::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[11]);
}

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

class DerivationExpression_ReturnProgram::_Internal {
 public:
  static const ::substrait::DerivationExpression& final_expression(const DerivationExpression_ReturnProgram* msg);
};

const ::substrait::DerivationExpression&
DerivationExpression_ReturnProgram::_Internal::final_expression(const DerivationExpression_ReturnProgram* msg) {
  return *msg->final_expression_;
}
DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  assignments_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram)
}
DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      assignments_(from.assignments_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_final_expression()) {
    final_expression_ = new ::substrait::DerivationExpression(*from.final_expression_);
  } else {
    final_expression_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram)
}

inline void DerivationExpression_ReturnProgram::SharedCtor() {
final_expression_ = nullptr;
}

DerivationExpression_ReturnProgram::~DerivationExpression_ReturnProgram() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression_ReturnProgram::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete final_expression_;
}

void DerivationExpression_ReturnProgram::ArenaDtor(void* object) {
  DerivationExpression_ReturnProgram* _this = reinterpret_cast< DerivationExpression_ReturnProgram* >(object);
  (void)_this;
}
void DerivationExpression_ReturnProgram::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression_ReturnProgram::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression_ReturnProgram::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  assignments_.Clear();
  if (GetArenaForAllocation() == nullptr && final_expression_ != nullptr) {
    delete final_expression_;
  }
  final_expression_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression_ReturnProgram::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1 [json_name = "assignments"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_assignments(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression final_expression = 2 [json_name = "finalExpression"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_final_expression(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression_ReturnProgram::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1 [json_name = "assignments"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_assignments_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_assignments(i), target, stream);
  }

  // .substrait.DerivationExpression final_expression = 2 [json_name = "finalExpression"];
  if (this->_internal_has_final_expression()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::final_expression(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ReturnProgram)
  return target;
}

size_t DerivationExpression_ReturnProgram::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1 [json_name = "assignments"];
  total_size += 1UL * this->_internal_assignments_size();
  for (const auto& msg : this->assignments_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.DerivationExpression final_expression = 2 [json_name = "finalExpression"];
  if (this->_internal_has_final_expression()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *final_expression_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ReturnProgram::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression_ReturnProgram::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ReturnProgram::GetClassData() const { return &_class_data_; }

void DerivationExpression_ReturnProgram::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression_ReturnProgram *>(to)->MergeFrom(
      static_cast<const DerivationExpression_ReturnProgram &>(from));
}


void DerivationExpression_ReturnProgram::MergeFrom(const DerivationExpression_ReturnProgram& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  assignments_.MergeFrom(from.assignments_);
  if (from._internal_has_final_expression()) {
    _internal_mutable_final_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_final_expression());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression_ReturnProgram::CopyFrom(const DerivationExpression_ReturnProgram& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ReturnProgram)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression_ReturnProgram::IsInitialized() const {
  return true;
}

void DerivationExpression_ReturnProgram::InternalSwap(DerivationExpression_ReturnProgram* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  assignments_.InternalSwap(&other->assignments_);
  swap(final_expression_, other->final_expression_);
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[12]);
}

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

class DerivationExpression::_Internal {
 public:
  static const ::substrait::Type_Boolean& bool_(const DerivationExpression* msg);
  static const ::substrait::Type_I8& i8(const DerivationExpression* msg);
  static const ::substrait::Type_I16& i16(const DerivationExpression* msg);
  static const ::substrait::Type_I32& i32(const DerivationExpression* msg);
  static const ::substrait::Type_I64& i64(const DerivationExpression* msg);
  static const ::substrait::Type_FP32& fp32(const DerivationExpression* msg);
  static const ::substrait::Type_FP64& fp64(const DerivationExpression* msg);
  static const ::substrait::Type_String& string(const DerivationExpression* msg);
  static const ::substrait::Type_Binary& binary(const DerivationExpression* msg);
  static const ::substrait::Type_Timestamp& timestamp(const DerivationExpression* msg);
  static const ::substrait::Type_Date& date(const DerivationExpression* msg);
  static const ::substrait::Type_Time& time(const DerivationExpression* msg);
  static const ::substrait::Type_IntervalYear& interval_year(const DerivationExpression* msg);
  static const ::substrait::Type_IntervalDay& interval_day(const DerivationExpression* msg);
  static const ::substrait::Type_TimestampTZ& timestamp_tz(const DerivationExpression* msg);
  static const ::substrait::Type_UUID& uuid(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_ExpressionFixedChar& fixed_char(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_ExpressionVarChar& varchar(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_ExpressionDecimal& decimal(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_ExpressionList& list(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_ExpressionMap& map(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_UnaryOp& unary_op(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_BinaryOp& binary_op(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_IfElse& if_else(const DerivationExpression* msg);
  static const ::substrait::DerivationExpression_ReturnProgram& return_program(const DerivationExpression* msg);
};

const ::substrait::Type_Boolean&
DerivationExpression::_Internal::bool_(const DerivationExpression* msg) {
  return *msg->kind_.bool__;
}
const ::substrait::Type_I8&
DerivationExpression::_Internal::i8(const DerivationExpression* msg) {
  return *msg->kind_.i8_;
}
const ::substrait::Type_I16&
DerivationExpression::_Internal::i16(const DerivationExpression* msg) {
  return *msg->kind_.i16_;
}
const ::substrait::Type_I32&
DerivationExpression::_Internal::i32(const DerivationExpression* msg) {
  return *msg->kind_.i32_;
}
const ::substrait::Type_I64&
DerivationExpression::_Internal::i64(const DerivationExpression* msg) {
  return *msg->kind_.i64_;
}
const ::substrait::Type_FP32&
DerivationExpression::_Internal::fp32(const DerivationExpression* msg) {
  return *msg->kind_.fp32_;
}
const ::substrait::Type_FP64&
DerivationExpression::_Internal::fp64(const DerivationExpression* msg) {
  return *msg->kind_.fp64_;
}
const ::substrait::Type_String&
DerivationExpression::_Internal::string(const DerivationExpression* msg) {
  return *msg->kind_.string_;
}
const ::substrait::Type_Binary&
DerivationExpression::_Internal::binary(const DerivationExpression* msg) {
  return *msg->kind_.binary_;
}
const ::substrait::Type_Timestamp&
DerivationExpression::_Internal::timestamp(const DerivationExpression* msg) {
  return *msg->kind_.timestamp_;
}
const ::substrait::Type_Date&
DerivationExpression::_Internal::date(const DerivationExpression* msg) {
  return *msg->kind_.date_;
}
const ::substrait::Type_Time&
DerivationExpression::_Internal::time(const DerivationExpression* msg) {
  return *msg->kind_.time_;
}
const ::substrait::Type_IntervalYear&
DerivationExpression::_Internal::interval_year(const DerivationExpression* msg) {
  return *msg->kind_.interval_year_;
}
const ::substrait::Type_IntervalDay&
DerivationExpression::_Internal::interval_day(const DerivationExpression* msg) {
  return *msg->kind_.interval_day_;
}
const ::substrait::Type_TimestampTZ&
DerivationExpression::_Internal::timestamp_tz(const DerivationExpression* msg) {
  return *msg->kind_.timestamp_tz_;
}
const ::substrait::Type_UUID&
DerivationExpression::_Internal::uuid(const DerivationExpression* msg) {
  return *msg->kind_.uuid_;
}
const ::substrait::DerivationExpression_ExpressionFixedChar&
DerivationExpression::_Internal::fixed_char(const DerivationExpression* msg) {
  return *msg->kind_.fixed_char_;
}
const ::substrait::DerivationExpression_ExpressionVarChar&
DerivationExpression::_Internal::varchar(const DerivationExpression* msg) {
  return *msg->kind_.varchar_;
}
const ::substrait::DerivationExpression_ExpressionFixedBinary&
DerivationExpression::_Internal::fixed_binary(const DerivationExpression* msg) {
  return *msg->kind_.fixed_binary_;
}
const ::substrait::DerivationExpression_ExpressionDecimal&
DerivationExpression::_Internal::decimal(const DerivationExpression* msg) {
  return *msg->kind_.decimal_;
}
const ::substrait::DerivationExpression_ExpressionStruct&
DerivationExpression::_Internal::struct_(const DerivationExpression* msg) {
  return *msg->kind_.struct__;
}
const ::substrait::DerivationExpression_ExpressionList&
DerivationExpression::_Internal::list(const DerivationExpression* msg) {
  return *msg->kind_.list_;
}
const ::substrait::DerivationExpression_ExpressionMap&
DerivationExpression::_Internal::map(const DerivationExpression* msg) {
  return *msg->kind_.map_;
}
const ::substrait::DerivationExpression_UnaryOp&
DerivationExpression::_Internal::unary_op(const DerivationExpression* msg) {
  return *msg->kind_.unary_op_;
}
const ::substrait::DerivationExpression_BinaryOp&
DerivationExpression::_Internal::binary_op(const DerivationExpression* msg) {
  return *msg->kind_.binary_op_;
}
const ::substrait::DerivationExpression_IfElse&
DerivationExpression::_Internal::if_else(const DerivationExpression* msg) {
  return *msg->kind_.if_else_;
}
const ::substrait::DerivationExpression_ReturnProgram&
DerivationExpression::_Internal::return_program(const DerivationExpression* msg) {
  return *msg->kind_.return_program_;
}
void DerivationExpression::set_allocated_bool_(::substrait::Type_Boolean* bool_) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (bool_) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_));
    if (message_arena != submessage_arena) {
      bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bool_, submessage_arena);
    }
    set_has_bool_();
    kind_.bool__ = bool_;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.bool)
}
void DerivationExpression::clear_bool_() {
  if (_internal_has_bool_()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.bool__;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_i8(::substrait::Type_I8* i8) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (i8) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8));
    if (message_arena != submessage_arena) {
      i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, i8, submessage_arena);
    }
    set_has_i8();
    kind_.i8_ = i8;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i8)
}
void DerivationExpression::clear_i8() {
  if (_internal_has_i8()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.i8_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_i16(::substrait::Type_I16* i16) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (i16) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16));
    if (message_arena != submessage_arena) {
      i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, i16, submessage_arena);
    }
    set_has_i16();
    kind_.i16_ = i16;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i16)
}
void DerivationExpression::clear_i16() {
  if (_internal_has_i16()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.i16_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_i32(::substrait::Type_I32* i32) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (i32) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32));
    if (message_arena != submessage_arena) {
      i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, i32, submessage_arena);
    }
    set_has_i32();
    kind_.i32_ = i32;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i32)
}
void DerivationExpression::clear_i32() {
  if (_internal_has_i32()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.i32_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_i64(::substrait::Type_I64* i64) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (i64) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64));
    if (message_arena != submessage_arena) {
      i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, i64, submessage_arena);
    }
    set_has_i64();
    kind_.i64_ = i64;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i64)
}
void DerivationExpression::clear_i64() {
  if (_internal_has_i64()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.i64_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_fp32(::substrait::Type_FP32* fp32) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (fp32) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32));
    if (message_arena != submessage_arena) {
      fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fp32, submessage_arena);
    }
    set_has_fp32();
    kind_.fp32_ = fp32;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fp32)
}
void DerivationExpression::clear_fp32() {
  if (_internal_has_fp32()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.fp32_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_fp64(::substrait::Type_FP64* fp64) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (fp64) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64));
    if (message_arena != submessage_arena) {
      fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fp64, submessage_arena);
    }
    set_has_fp64();
    kind_.fp64_ = fp64;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fp64)
}
void DerivationExpression::clear_fp64() {
  if (_internal_has_fp64()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.fp64_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_string(::substrait::Type_String* string) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (string) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string));
    if (message_arena != submessage_arena) {
      string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, string, submessage_arena);
    }
    set_has_string();
    kind_.string_ = string;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.string)
}
void DerivationExpression::clear_string() {
  if (_internal_has_string()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.string_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_binary(::substrait::Type_Binary* binary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (binary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary));
    if (message_arena != submessage_arena) {
      binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, binary, submessage_arena);
    }
    set_has_binary();
    kind_.binary_ = binary;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.binary)
}
void DerivationExpression::clear_binary() {
  if (_internal_has_binary()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.binary_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (timestamp) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp));
    if (message_arena != submessage_arena) {
      timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, timestamp, submessage_arena);
    }
    set_has_timestamp();
    kind_.timestamp_ = timestamp;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.timestamp)
}
void DerivationExpression::clear_timestamp() {
  if (_internal_has_timestamp()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.timestamp_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_date(::substrait::Type_Date* date) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (date) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date));
    if (message_arena != submessage_arena) {
      date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, date, submessage_arena);
    }
    set_has_date();
    kind_.date_ = date;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.date)
}
void DerivationExpression::clear_date() {
  if (_internal_has_date()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.date_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_time(::substrait::Type_Time* time) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (time) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time));
    if (message_arena != submessage_arena) {
      time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, time, submessage_arena);
    }
    set_has_time();
    kind_.time_ = time;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.time)
}
void DerivationExpression::clear_time() {
  if (_internal_has_time()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.time_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (interval_year) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year));
    if (message_arena != submessage_arena) {
      interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interval_year, submessage_arena);
    }
    set_has_interval_year();
    kind_.interval_year_ = interval_year;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.interval_year)
}
void DerivationExpression::clear_interval_year() {
  if (_internal_has_interval_year()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.interval_year_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (interval_day) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day));
    if (message_arena != submessage_arena) {
      interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interval_day, submessage_arena);
    }
    set_has_interval_day();
    kind_.interval_day_ = interval_day;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.interval_day)
}
void DerivationExpression::clear_interval_day() {
  if (_internal_has_interval_day()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.interval_day_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (timestamp_tz) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz));
    if (message_arena != submessage_arena) {
      timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, timestamp_tz, submessage_arena);
    }
    set_has_timestamp_tz();
    kind_.timestamp_tz_ = timestamp_tz;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.timestamp_tz)
}
void DerivationExpression::clear_timestamp_tz() {
  if (_internal_has_timestamp_tz()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.timestamp_tz_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_uuid(::substrait::Type_UUID* uuid) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (uuid) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid));
    if (message_arena != submessage_arena) {
      uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, uuid, submessage_arena);
    }
    set_has_uuid();
    kind_.uuid_ = uuid;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.uuid)
}
void DerivationExpression::clear_uuid() {
  if (_internal_has_uuid()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kind_.uuid_;
    }
    clear_has_kind();
  }
}
void DerivationExpression::set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (fixed_char) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionFixedChar>::GetOwningArena(fixed_char);
    if (message_arena != submessage_arena) {
      fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fixed_char, submessage_arena);
    }
    set_has_fixed_char();
    kind_.fixed_char_ = fixed_char;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_char)
}
void DerivationExpression::set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (varchar) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionVarChar>::GetOwningArena(varchar);
    if (message_arena != submessage_arena) {
      varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, varchar, submessage_arena);
    }
    set_has_varchar();
    kind_.varchar_ = varchar;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.varchar)
}
void DerivationExpression::set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (fixed_binary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionFixedBinary>::GetOwningArena(fixed_binary);
    if (message_arena != submessage_arena) {
      fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fixed_binary, submessage_arena);
    }
    set_has_fixed_binary();
    kind_.fixed_binary_ = fixed_binary;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_binary)
}
void DerivationExpression::set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (decimal) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionDecimal>::GetOwningArena(decimal);
    if (message_arena != submessage_arena) {
      decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, decimal, submessage_arena);
    }
    set_has_decimal();
    kind_.decimal_ = decimal;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.decimal)
}
void DerivationExpression::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  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);
    }
    set_has_struct_();
    kind_.struct__ = struct_;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.struct)
}
void DerivationExpression::set_allocated_list(::substrait::DerivationExpression_ExpressionList* list) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (list) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionList>::GetOwningArena(list);
    if (message_arena != submessage_arena) {
      list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, list, submessage_arena);
    }
    set_has_list();
    kind_.list_ = list;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.list)
}
void DerivationExpression::set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (map) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionMap>::GetOwningArena(map);
    if (message_arena != submessage_arena) {
      map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, map, submessage_arena);
    }
    set_has_map();
    kind_.map_ = map;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.map)
}
void DerivationExpression::set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (unary_op) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_UnaryOp>::GetOwningArena(unary_op);
    if (message_arena != submessage_arena) {
      unary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unary_op, submessage_arena);
    }
    set_has_unary_op();
    kind_.unary_op_ = unary_op;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.unary_op)
}
void DerivationExpression::set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (binary_op) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_BinaryOp>::GetOwningArena(binary_op);
    if (message_arena != submessage_arena) {
      binary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, binary_op, submessage_arena);
    }
    set_has_binary_op();
    kind_.binary_op_ = binary_op;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.binary_op)
}
void DerivationExpression::set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (if_else) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_IfElse>::GetOwningArena(if_else);
    if (message_arena != submessage_arena) {
      if_else = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, if_else, submessage_arena);
    }
    set_has_if_else();
    kind_.if_else_ = if_else;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.if_else)
}
void DerivationExpression::set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (return_program) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ReturnProgram>::GetOwningArena(return_program);
    if (message_arena != submessage_arena) {
      return_program = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, return_program, submessage_arena);
    }
    set_has_return_program();
    kind_.return_program_ = return_program;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.return_program)
}
DerivationExpression::DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression)
}
DerivationExpression::DerivationExpression(const DerivationExpression& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_kind();
  switch (from.kind_case()) {
    case kBool: {
      _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_());
      break;
    }
    case kI8: {
      _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8());
      break;
    }
    case kI16: {
      _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16());
      break;
    }
    case kI32: {
      _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32());
      break;
    }
    case kI64: {
      _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64());
      break;
    }
    case kFp32: {
      _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32());
      break;
    }
    case kFp64: {
      _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64());
      break;
    }
    case kString: {
      _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string());
      break;
    }
    case kBinary: {
      _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary());
      break;
    }
    case kTimestamp: {
      _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp());
      break;
    }
    case kDate: {
      _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date());
      break;
    }
    case kTime: {
      _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time());
      break;
    }
    case kIntervalYear: {
      _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year());
      break;
    }
    case kIntervalDay: {
      _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day());
      break;
    }
    case kTimestampTz: {
      _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz());
      break;
    }
    case kUuid: {
      _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid());
      break;
    }
    case kFixedChar: {
      _internal_mutable_fixed_char()->::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char());
      break;
    }
    case kVarchar: {
      _internal_mutable_varchar()->::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar());
      break;
    }
    case kFixedBinary: {
      _internal_mutable_fixed_binary()->::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary());
      break;
    }
    case kDecimal: {
      _internal_mutable_decimal()->::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal());
      break;
    }
    case kStruct: {
      _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_());
      break;
    }
    case kList: {
      _internal_mutable_list()->::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list());
      break;
    }
    case kMap: {
      _internal_mutable_map()->::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map());
      break;
    }
    case kUserDefinedPointer: {
      _internal_set_user_defined_pointer(from._internal_user_defined_pointer());
      break;
    }
    case kTypeParameterName: {
      _internal_set_type_parameter_name(from._internal_type_parameter_name());
      break;
    }
    case kIntegerParameterName: {
      _internal_set_integer_parameter_name(from._internal_integer_parameter_name());
      break;
    }
    case kIntegerLiteral: {
      _internal_set_integer_literal(from._internal_integer_literal());
      break;
    }
    case kUnaryOp: {
      _internal_mutable_unary_op()->::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op());
      break;
    }
    case kBinaryOp: {
      _internal_mutable_binary_op()->::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op());
      break;
    }
    case kIfElse: {
      _internal_mutable_if_else()->::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else());
      break;
    }
    case kReturnProgram: {
      _internal_mutable_return_program()->::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program());
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression)
}

inline void DerivationExpression::SharedCtor() {
clear_has_kind();
}

DerivationExpression::~DerivationExpression() {
  // @@protoc_insertion_point(destructor:substrait.DerivationExpression)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void DerivationExpression::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_kind()) {
    clear_kind();
  }
}

void DerivationExpression::ArenaDtor(void* object) {
  DerivationExpression* _this = reinterpret_cast< DerivationExpression* >(object);
  (void)_this;
}
void DerivationExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DerivationExpression::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void DerivationExpression::clear_kind() {
// @@protoc_insertion_point(one_of_clear_start:substrait.DerivationExpression)
  switch (kind_case()) {
    case kBool: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.bool__;
      }
      break;
    }
    case kI8: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.i8_;
      }
      break;
    }
    case kI16: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.i16_;
      }
      break;
    }
    case kI32: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.i32_;
      }
      break;
    }
    case kI64: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.i64_;
      }
      break;
    }
    case kFp32: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.fp32_;
      }
      break;
    }
    case kFp64: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.fp64_;
      }
      break;
    }
    case kString: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.string_;
      }
      break;
    }
    case kBinary: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.binary_;
      }
      break;
    }
    case kTimestamp: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.timestamp_;
      }
      break;
    }
    case kDate: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.date_;
      }
      break;
    }
    case kTime: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.time_;
      }
      break;
    }
    case kIntervalYear: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.interval_year_;
      }
      break;
    }
    case kIntervalDay: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.interval_day_;
      }
      break;
    }
    case kTimestampTz: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.timestamp_tz_;
      }
      break;
    }
    case kUuid: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.uuid_;
      }
      break;
    }
    case kFixedChar: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.fixed_char_;
      }
      break;
    }
    case kVarchar: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.varchar_;
      }
      break;
    }
    case kFixedBinary: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.fixed_binary_;
      }
      break;
    }
    case kDecimal: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.decimal_;
      }
      break;
    }
    case kStruct: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.struct__;
      }
      break;
    }
    case kList: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.list_;
      }
      break;
    }
    case kMap: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.map_;
      }
      break;
    }
    case kUserDefinedPointer: {
      // No need to clear
      break;
    }
    case kTypeParameterName: {
      kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kIntegerParameterName: {
      kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kIntegerLiteral: {
      // No need to clear
      break;
    }
    case kUnaryOp: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.unary_op_;
      }
      break;
    }
    case kBinaryOp: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.binary_op_;
      }
      break;
    }
    case kIfElse: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.if_else_;
      }
      break;
    }
    case kReturnProgram: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.return_program_;
      }
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = KIND_NOT_SET;
}


void DerivationExpression::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_kind();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .substrait.Type.Boolean bool = 1 [json_name = "bool"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.I8 i8 = 2 [json_name = "i8"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.I16 i16 = 3 [json_name = "i16"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.I32 i32 = 5 [json_name = "i32"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.I64 i64 = 7 [json_name = "i64"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.FP32 fp32 = 10 [json_name = "fp32"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.FP64 fp64 = 11 [json_name = "fp64"];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.String string = 12 [json_name = "string"];
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_string(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Binary binary = 13 [json_name = "binary"];
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Timestamp timestamp = 14 [json_name = "timestamp"];
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Date date = 16 [json_name = "date"];
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
          ptr = ctx->ParseMessage(_internal_mutable_date(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Time time = 17 [json_name = "time"];
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
          ptr = ctx->ParseMessage(_internal_mutable_time(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.IntervalYear interval_year = 19 [json_name = "intervalYear"];
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
          ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.IntervalDay interval_day = 20 [json_name = "intervalDay"];
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21 [json_name = "fixedChar"];
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
          ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.ExpressionVarChar varchar = 22 [json_name = "varchar"];
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
          ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23 [json_name = "fixedBinary"];
      case 23:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
          ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.ExpressionDecimal decimal = 24 [json_name = "decimal"];
      case 24:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
          ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.ExpressionStruct struct = 25 [json_name = "struct"];
      case 25:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 202)) {
          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.ExpressionList list = 27 [json_name = "list"];
      case 27:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 218)) {
          ptr = ctx->ParseMessage(_internal_mutable_list(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.ExpressionMap map = 28 [json_name = "map"];
      case 28:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
          ptr = ctx->ParseMessage(_internal_mutable_map(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.TimestampTZ timestamp_tz = 29 [json_name = "timestampTz"];
      case 29:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
          ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint32 user_defined_pointer = 31 [json_name = "userDefinedPointer"];
      case 31:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
          _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.UUID uuid = 32 [json_name = "uuid"];
      case 32:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
          ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string type_parameter_name = 33 [json_name = "typeParameterName"];
      case 33:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_type_parameter_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.type_parameter_name"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string integer_parameter_name = 34 [json_name = "integerParameterName"];
      case 34:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_integer_parameter_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.integer_parameter_name"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 integer_literal = 35 [json_name = "integerLiteral"];
      case 35:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.UnaryOp unary_op = 36 [json_name = "unaryOp"];
      case 36:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_unary_op(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.BinaryOp binary_op = 37 [json_name = "binaryOp"];
      case 37:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_binary_op(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.IfElse if_else = 38 [json_name = "ifElse"];
      case 38:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_if_else(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression.ReturnProgram return_program = 39 [json_name = "returnProgram"];
      case 39:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_return_program(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* DerivationExpression::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Type.Boolean bool = 1 [json_name = "bool"];
  if (_internal_has_bool_()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::bool_(this), target, stream);
  }

  // .substrait.Type.I8 i8 = 2 [json_name = "i8"];
  if (_internal_has_i8()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::i8(this), target, stream);
  }

  // .substrait.Type.I16 i16 = 3 [json_name = "i16"];
  if (_internal_has_i16()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::i16(this), target, stream);
  }

  // .substrait.Type.I32 i32 = 5 [json_name = "i32"];
  if (_internal_has_i32()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::i32(this), target, stream);
  }

  // .substrait.Type.I64 i64 = 7 [json_name = "i64"];
  if (_internal_has_i64()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::i64(this), target, stream);
  }

  // .substrait.Type.FP32 fp32 = 10 [json_name = "fp32"];
  if (_internal_has_fp32()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::fp32(this), target, stream);
  }

  // .substrait.Type.FP64 fp64 = 11 [json_name = "fp64"];
  if (_internal_has_fp64()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::fp64(this), target, stream);
  }

  // .substrait.Type.String string = 12 [json_name = "string"];
  if (_internal_has_string()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        12, _Internal::string(this), target, stream);
  }

  // .substrait.Type.Binary binary = 13 [json_name = "binary"];
  if (_internal_has_binary()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        13, _Internal::binary(this), target, stream);
  }

  // .substrait.Type.Timestamp timestamp = 14 [json_name = "timestamp"];
  if (_internal_has_timestamp()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        14, _Internal::timestamp(this), target, stream);
  }

  // .substrait.Type.Date date = 16 [json_name = "date"];
  if (_internal_has_date()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        16, _Internal::date(this), target, stream);
  }

  // .substrait.Type.Time time = 17 [json_name = "time"];
  if (_internal_has_time()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        17, _Internal::time(this), target, stream);
  }

  // .substrait.Type.IntervalYear interval_year = 19 [json_name = "intervalYear"];
  if (_internal_has_interval_year()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        19, _Internal::interval_year(this), target, stream);
  }

  // .substrait.Type.IntervalDay interval_day = 20 [json_name = "intervalDay"];
  if (_internal_has_interval_day()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        20, _Internal::interval_day(this), target, stream);
  }

  // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21 [json_name = "fixedChar"];
  if (_internal_has_fixed_char()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        21, _Internal::fixed_char(this), target, stream);
  }

  // .substrait.DerivationExpression.ExpressionVarChar varchar = 22 [json_name = "varchar"];
  if (_internal_has_varchar()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        22, _Internal::varchar(this), target, stream);
  }

  // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23 [json_name = "fixedBinary"];
  if (_internal_has_fixed_binary()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        23, _Internal::fixed_binary(this), target, stream);
  }

  // .substrait.DerivationExpression.ExpressionDecimal decimal = 24 [json_name = "decimal"];
  if (_internal_has_decimal()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        24, _Internal::decimal(this), target, stream);
  }

  // .substrait.DerivationExpression.ExpressionStruct struct = 25 [json_name = "struct"];
  if (_internal_has_struct_()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        25, _Internal::struct_(this), target, stream);
  }

  // .substrait.DerivationExpression.ExpressionList list = 27 [json_name = "list"];
  if (_internal_has_list()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        27, _Internal::list(this), target, stream);
  }

  // .substrait.DerivationExpression.ExpressionMap map = 28 [json_name = "map"];
  if (_internal_has_map()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        28, _Internal::map(this), target, stream);
  }

  // .substrait.Type.TimestampTZ timestamp_tz = 29 [json_name = "timestampTz"];
  if (_internal_has_timestamp_tz()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        29, _Internal::timestamp_tz(this), target, stream);
  }

  // uint32 user_defined_pointer = 31 [json_name = "userDefinedPointer"];
  if (_internal_has_user_defined_pointer()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_pointer(), target);
  }

  // .substrait.Type.UUID uuid = 32 [json_name = "uuid"];
  if (_internal_has_uuid()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        32, _Internal::uuid(this), target, stream);
  }

  // string type_parameter_name = 33 [json_name = "typeParameterName"];
  if (_internal_has_type_parameter_name()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_type_parameter_name().data(), static_cast<int>(this->_internal_type_parameter_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.DerivationExpression.type_parameter_name");
    target = stream->WriteStringMaybeAliased(
        33, this->_internal_type_parameter_name(), target);
  }

  // string integer_parameter_name = 34 [json_name = "integerParameterName"];
  if (_internal_has_integer_parameter_name()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_integer_parameter_name().data(), static_cast<int>(this->_internal_integer_parameter_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.DerivationExpression.integer_parameter_name");
    target = stream->WriteStringMaybeAliased(
        34, this->_internal_integer_parameter_name(), target);
  }

  // int32 integer_literal = 35 [json_name = "integerLiteral"];
  if (_internal_has_integer_literal()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(35, this->_internal_integer_literal(), target);
  }

  // .substrait.DerivationExpression.UnaryOp unary_op = 36 [json_name = "unaryOp"];
  if (_internal_has_unary_op()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        36, _Internal::unary_op(this), target, stream);
  }

  // .substrait.DerivationExpression.BinaryOp binary_op = 37 [json_name = "binaryOp"];
  if (_internal_has_binary_op()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        37, _Internal::binary_op(this), target, stream);
  }

  // .substrait.DerivationExpression.IfElse if_else = 38 [json_name = "ifElse"];
  if (_internal_has_if_else()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        38, _Internal::if_else(this), target, stream);
  }

  // .substrait.DerivationExpression.ReturnProgram return_program = 39 [json_name = "returnProgram"];
  if (_internal_has_return_program()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        39, _Internal::return_program(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression)
  return target;
}

size_t DerivationExpression::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (kind_case()) {
    // .substrait.Type.Boolean bool = 1 [json_name = "bool"];
    case kBool: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.bool__);
      break;
    }
    // .substrait.Type.I8 i8 = 2 [json_name = "i8"];
    case kI8: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.i8_);
      break;
    }
    // .substrait.Type.I16 i16 = 3 [json_name = "i16"];
    case kI16: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.i16_);
      break;
    }
    // .substrait.Type.I32 i32 = 5 [json_name = "i32"];
    case kI32: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.i32_);
      break;
    }
    // .substrait.Type.I64 i64 = 7 [json_name = "i64"];
    case kI64: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.i64_);
      break;
    }
    // .substrait.Type.FP32 fp32 = 10 [json_name = "fp32"];
    case kFp32: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.fp32_);
      break;
    }
    // .substrait.Type.FP64 fp64 = 11 [json_name = "fp64"];
    case kFp64: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.fp64_);
      break;
    }
    // .substrait.Type.String string = 12 [json_name = "string"];
    case kString: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.string_);
      break;
    }
    // .substrait.Type.Binary binary = 13 [json_name = "binary"];
    case kBinary: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.binary_);
      break;
    }
    // .substrait.Type.Timestamp timestamp = 14 [json_name = "timestamp"];
    case kTimestamp: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.timestamp_);
      break;
    }
    // .substrait.Type.Date date = 16 [json_name = "date"];
    case kDate: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.date_);
      break;
    }
    // .substrait.Type.Time time = 17 [json_name = "time"];
    case kTime: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.time_);
      break;
    }
    // .substrait.Type.IntervalYear interval_year = 19 [json_name = "intervalYear"];
    case kIntervalYear: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.interval_year_);
      break;
    }
    // .substrait.Type.IntervalDay interval_day = 20 [json_name = "intervalDay"];
    case kIntervalDay: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.interval_day_);
      break;
    }
    // .substrait.Type.TimestampTZ timestamp_tz = 29 [json_name = "timestampTz"];
    case kTimestampTz: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.timestamp_tz_);
      break;
    }
    // .substrait.Type.UUID uuid = 32 [json_name = "uuid"];
    case kUuid: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.uuid_);
      break;
    }
    // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21 [json_name = "fixedChar"];
    case kFixedChar: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.fixed_char_);
      break;
    }
    // .substrait.DerivationExpression.ExpressionVarChar varchar = 22 [json_name = "varchar"];
    case kVarchar: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.varchar_);
      break;
    }
    // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23 [json_name = "fixedBinary"];
    case kFixedBinary: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.fixed_binary_);
      break;
    }
    // .substrait.DerivationExpression.ExpressionDecimal decimal = 24 [json_name = "decimal"];
    case kDecimal: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.decimal_);
      break;
    }
    // .substrait.DerivationExpression.ExpressionStruct struct = 25 [json_name = "struct"];
    case kStruct: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.struct__);
      break;
    }
    // .substrait.DerivationExpression.ExpressionList list = 27 [json_name = "list"];
    case kList: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.list_);
      break;
    }
    // .substrait.DerivationExpression.ExpressionMap map = 28 [json_name = "map"];
    case kMap: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.map_);
      break;
    }
    // uint32 user_defined_pointer = 31 [json_name = "userDefinedPointer"];
    case kUserDefinedPointer: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_user_defined_pointer());
      break;
    }
    // string type_parameter_name = 33 [json_name = "typeParameterName"];
    case kTypeParameterName: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_type_parameter_name());
      break;
    }
    // string integer_parameter_name = 34 [json_name = "integerParameterName"];
    case kIntegerParameterName: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_integer_parameter_name());
      break;
    }
    // int32 integer_literal = 35 [json_name = "integerLiteral"];
    case kIntegerLiteral: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_integer_literal());
      break;
    }
    // .substrait.DerivationExpression.UnaryOp unary_op = 36 [json_name = "unaryOp"];
    case kUnaryOp: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.unary_op_);
      break;
    }
    // .substrait.DerivationExpression.BinaryOp binary_op = 37 [json_name = "binaryOp"];
    case kBinaryOp: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.binary_op_);
      break;
    }
    // .substrait.DerivationExpression.IfElse if_else = 38 [json_name = "ifElse"];
    case kIfElse: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.if_else_);
      break;
    }
    // .substrait.DerivationExpression.ReturnProgram return_program = 39 [json_name = "returnProgram"];
    case kReturnProgram: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.return_program_);
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    DerivationExpression::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression::GetClassData() const { return &_class_data_; }

void DerivationExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<DerivationExpression *>(to)->MergeFrom(
      static_cast<const DerivationExpression &>(from));
}


void DerivationExpression::MergeFrom(const DerivationExpression& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.kind_case()) {
    case kBool: {
      _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_());
      break;
    }
    case kI8: {
      _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8());
      break;
    }
    case kI16: {
      _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16());
      break;
    }
    case kI32: {
      _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32());
      break;
    }
    case kI64: {
      _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64());
      break;
    }
    case kFp32: {
      _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32());
      break;
    }
    case kFp64: {
      _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64());
      break;
    }
    case kString: {
      _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string());
      break;
    }
    case kBinary: {
      _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary());
      break;
    }
    case kTimestamp: {
      _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp());
      break;
    }
    case kDate: {
      _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date());
      break;
    }
    case kTime: {
      _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time());
      break;
    }
    case kIntervalYear: {
      _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year());
      break;
    }
    case kIntervalDay: {
      _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day());
      break;
    }
    case kTimestampTz: {
      _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz());
      break;
    }
    case kUuid: {
      _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid());
      break;
    }
    case kFixedChar: {
      _internal_mutable_fixed_char()->::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char());
      break;
    }
    case kVarchar: {
      _internal_mutable_varchar()->::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar());
      break;
    }
    case kFixedBinary: {
      _internal_mutable_fixed_binary()->::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary());
      break;
    }
    case kDecimal: {
      _internal_mutable_decimal()->::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal());
      break;
    }
    case kStruct: {
      _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_());
      break;
    }
    case kList: {
      _internal_mutable_list()->::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list());
      break;
    }
    case kMap: {
      _internal_mutable_map()->::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map());
      break;
    }
    case kUserDefinedPointer: {
      _internal_set_user_defined_pointer(from._internal_user_defined_pointer());
      break;
    }
    case kTypeParameterName: {
      _internal_set_type_parameter_name(from._internal_type_parameter_name());
      break;
    }
    case kIntegerParameterName: {
      _internal_set_integer_parameter_name(from._internal_integer_parameter_name());
      break;
    }
    case kIntegerLiteral: {
      _internal_set_integer_literal(from._internal_integer_literal());
      break;
    }
    case kUnaryOp: {
      _internal_mutable_unary_op()->::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op());
      break;
    }
    case kBinaryOp: {
      _internal_mutable_binary_op()->::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op());
      break;
    }
    case kIfElse: {
      _internal_mutable_if_else()->::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else());
      break;
    }
    case kReturnProgram: {
      _internal_mutable_return_program()->::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program());
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void DerivationExpression::CopyFrom(const DerivationExpression& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DerivationExpression::IsInitialized() const {
  return true;
}

void DerivationExpression::InternalSwap(DerivationExpression* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(kind_, other->kind_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[13]);
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace substrait
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionFixedChar >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionVarChar >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionFixedBinary >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionDecimal >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionStruct >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionNamedStruct >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionNamedStruct >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionList >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionMap >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_IfElse >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_UnaryOp >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_BinaryOp >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram_Assignment >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ReturnProgram_Assignment >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ReturnProgram >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression* Arena::CreateMaybeMessage< ::substrait::DerivationExpression >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::DerivationExpression >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
