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

#include "substrait/algebra.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 RelCommon_Direct::RelCommon_Direct(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct RelCommon_DirectDefaultTypeInternal {
  constexpr RelCommon_DirectDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RelCommon_DirectDefaultTypeInternal() {}
  union {
    RelCommon_Direct _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_DirectDefaultTypeInternal _RelCommon_Direct_default_instance_;
constexpr RelCommon_Emit::RelCommon_Emit(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : output_mapping_()
  , _output_mapping_cached_byte_size_(0){}
struct RelCommon_EmitDefaultTypeInternal {
  constexpr RelCommon_EmitDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RelCommon_EmitDefaultTypeInternal() {}
  union {
    RelCommon_Emit _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_EmitDefaultTypeInternal _RelCommon_Emit_default_instance_;
constexpr RelCommon_Hint_Stats::RelCommon_Hint_Stats(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : advanced_extension_(nullptr)
  , row_count_(0)
  , record_size_(0){}
struct RelCommon_Hint_StatsDefaultTypeInternal {
  constexpr RelCommon_Hint_StatsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RelCommon_Hint_StatsDefaultTypeInternal() {}
  union {
    RelCommon_Hint_Stats _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_StatsDefaultTypeInternal _RelCommon_Hint_Stats_default_instance_;
constexpr RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : advanced_extension_(nullptr){}
struct RelCommon_Hint_RuntimeConstraintDefaultTypeInternal {
  constexpr RelCommon_Hint_RuntimeConstraintDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RelCommon_Hint_RuntimeConstraintDefaultTypeInternal() {}
  union {
    RelCommon_Hint_RuntimeConstraint _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_RuntimeConstraintDefaultTypeInternal _RelCommon_Hint_RuntimeConstraint_default_instance_;
constexpr RelCommon_Hint::RelCommon_Hint(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : stats_(nullptr)
  , constraint_(nullptr)
  , advanced_extension_(nullptr){}
struct RelCommon_HintDefaultTypeInternal {
  constexpr RelCommon_HintDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RelCommon_HintDefaultTypeInternal() {}
  union {
    RelCommon_Hint _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_HintDefaultTypeInternal _RelCommon_Hint_default_instance_;
constexpr RelCommon::RelCommon(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : hint_(nullptr)
  , advanced_extension_(nullptr)
  , _oneof_case_{}{}
struct RelCommonDefaultTypeInternal {
  constexpr RelCommonDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RelCommonDefaultTypeInternal() {}
  union {
    RelCommon _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommonDefaultTypeInternal _RelCommon_default_instance_;
constexpr ReadRel_NamedTable::ReadRel_NamedTable(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : names_()
  , advanced_extension_(nullptr){}
struct ReadRel_NamedTableDefaultTypeInternal {
  constexpr ReadRel_NamedTableDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReadRel_NamedTableDefaultTypeInternal() {}
  union {
    ReadRel_NamedTable _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_NamedTableDefaultTypeInternal _ReadRel_NamedTable_default_instance_;
constexpr ReadRel_VirtualTable::ReadRel_VirtualTable(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : values_(){}
struct ReadRel_VirtualTableDefaultTypeInternal {
  constexpr ReadRel_VirtualTableDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReadRel_VirtualTableDefaultTypeInternal() {}
  union {
    ReadRel_VirtualTable _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_VirtualTableDefaultTypeInternal _ReadRel_VirtualTable_default_instance_;
constexpr ReadRel_ExtensionTable::ReadRel_ExtensionTable(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : detail_(nullptr){}
struct ReadRel_ExtensionTableDefaultTypeInternal {
  constexpr ReadRel_ExtensionTableDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReadRel_ExtensionTableDefaultTypeInternal() {}
  union {
    ReadRel_ExtensionTable _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_ExtensionTableDefaultTypeInternal _ReadRel_ExtensionTable_default_instance_;
constexpr ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : format_(0)

  , partition_index_(uint64_t{0u})
  , start_(uint64_t{0u})
  , length_(uint64_t{0u})
  , _oneof_case_{}{}
struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal {
  constexpr ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal() {}
  union {
    ReadRel_LocalFiles_FileOrFiles _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal _ReadRel_LocalFiles_FileOrFiles_default_instance_;
constexpr ReadRel_LocalFiles::ReadRel_LocalFiles(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : items_()
  , advanced_extension_(nullptr){}
struct ReadRel_LocalFilesDefaultTypeInternal {
  constexpr ReadRel_LocalFilesDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReadRel_LocalFilesDefaultTypeInternal() {}
  union {
    ReadRel_LocalFiles _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_LocalFilesDefaultTypeInternal _ReadRel_LocalFiles_default_instance_;
constexpr ReadRel::ReadRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : common_(nullptr)
  , base_schema_(nullptr)
  , filter_(nullptr)
  , projection_(nullptr)
  , advanced_extension_(nullptr)
  , _oneof_case_{}{}
struct ReadRelDefaultTypeInternal {
  constexpr ReadRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReadRelDefaultTypeInternal() {}
  union {
    ReadRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRelDefaultTypeInternal _ReadRel_default_instance_;
constexpr ProjectRel::ProjectRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : expressions_()
  , common_(nullptr)
  , input_(nullptr)
  , advanced_extension_(nullptr){}
struct ProjectRelDefaultTypeInternal {
  constexpr ProjectRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ProjectRelDefaultTypeInternal() {}
  union {
    ProjectRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ProjectRelDefaultTypeInternal _ProjectRel_default_instance_;
constexpr JoinRel::JoinRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : common_(nullptr)
  , left_(nullptr)
  , right_(nullptr)
  , expression_(nullptr)
  , post_join_filter_(nullptr)
  , advanced_extension_(nullptr)
  , type_(0)
{}
struct JoinRelDefaultTypeInternal {
  constexpr JoinRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~JoinRelDefaultTypeInternal() {}
  union {
    JoinRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT JoinRelDefaultTypeInternal _JoinRel_default_instance_;
constexpr CrossRel::CrossRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : common_(nullptr)
  , left_(nullptr)
  , right_(nullptr)
  , advanced_extension_(nullptr){}
struct CrossRelDefaultTypeInternal {
  constexpr CrossRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CrossRelDefaultTypeInternal() {}
  union {
    CrossRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CrossRelDefaultTypeInternal _CrossRel_default_instance_;
constexpr FetchRel::FetchRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : common_(nullptr)
  , input_(nullptr)
  , advanced_extension_(nullptr)
  , offset_(int64_t{0})
  , count_(int64_t{0}){}
struct FetchRelDefaultTypeInternal {
  constexpr FetchRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FetchRelDefaultTypeInternal() {}
  union {
    FetchRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FetchRelDefaultTypeInternal _FetchRel_default_instance_;
constexpr AggregateRel_Grouping::AggregateRel_Grouping(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : grouping_expressions_(){}
struct AggregateRel_GroupingDefaultTypeInternal {
  constexpr AggregateRel_GroupingDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AggregateRel_GroupingDefaultTypeInternal() {}
  union {
    AggregateRel_Grouping _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRel_GroupingDefaultTypeInternal _AggregateRel_Grouping_default_instance_;
constexpr AggregateRel_Measure::AggregateRel_Measure(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : measure_(nullptr)
  , filter_(nullptr){}
struct AggregateRel_MeasureDefaultTypeInternal {
  constexpr AggregateRel_MeasureDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AggregateRel_MeasureDefaultTypeInternal() {}
  union {
    AggregateRel_Measure _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRel_MeasureDefaultTypeInternal _AggregateRel_Measure_default_instance_;
constexpr AggregateRel::AggregateRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : groupings_()
  , measures_()
  , common_(nullptr)
  , input_(nullptr)
  , advanced_extension_(nullptr){}
struct AggregateRelDefaultTypeInternal {
  constexpr AggregateRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AggregateRelDefaultTypeInternal() {}
  union {
    AggregateRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRelDefaultTypeInternal _AggregateRel_default_instance_;
constexpr SortRel::SortRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : sorts_()
  , common_(nullptr)
  , input_(nullptr)
  , advanced_extension_(nullptr){}
struct SortRelDefaultTypeInternal {
  constexpr SortRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SortRelDefaultTypeInternal() {}
  union {
    SortRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SortRelDefaultTypeInternal _SortRel_default_instance_;
constexpr FilterRel::FilterRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : common_(nullptr)
  , input_(nullptr)
  , condition_(nullptr)
  , advanced_extension_(nullptr){}
struct FilterRelDefaultTypeInternal {
  constexpr FilterRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FilterRelDefaultTypeInternal() {}
  union {
    FilterRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FilterRelDefaultTypeInternal _FilterRel_default_instance_;
constexpr SetRel::SetRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : inputs_()
  , common_(nullptr)
  , advanced_extension_(nullptr)
  , op_(0)
{}
struct SetRelDefaultTypeInternal {
  constexpr SetRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SetRelDefaultTypeInternal() {}
  union {
    SetRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SetRelDefaultTypeInternal _SetRel_default_instance_;
constexpr ExtensionSingleRel::ExtensionSingleRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : common_(nullptr)
  , input_(nullptr)
  , detail_(nullptr){}
struct ExtensionSingleRelDefaultTypeInternal {
  constexpr ExtensionSingleRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ExtensionSingleRelDefaultTypeInternal() {}
  union {
    ExtensionSingleRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionSingleRelDefaultTypeInternal _ExtensionSingleRel_default_instance_;
constexpr ExtensionLeafRel::ExtensionLeafRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : common_(nullptr)
  , detail_(nullptr){}
struct ExtensionLeafRelDefaultTypeInternal {
  constexpr ExtensionLeafRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ExtensionLeafRelDefaultTypeInternal() {}
  union {
    ExtensionLeafRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionLeafRelDefaultTypeInternal _ExtensionLeafRel_default_instance_;
constexpr ExtensionMultiRel::ExtensionMultiRel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : inputs_()
  , common_(nullptr)
  , detail_(nullptr){}
struct ExtensionMultiRelDefaultTypeInternal {
  constexpr ExtensionMultiRelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ExtensionMultiRelDefaultTypeInternal() {}
  union {
    ExtensionMultiRel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionMultiRelDefaultTypeInternal _ExtensionMultiRel_default_instance_;
constexpr RelRoot::RelRoot(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : names_()
  , input_(nullptr){}
struct RelRootDefaultTypeInternal {
  constexpr RelRootDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RelRootDefaultTypeInternal() {}
  union {
    RelRoot _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelRootDefaultTypeInternal _RelRoot_default_instance_;
constexpr Rel::Rel(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct RelDefaultTypeInternal {
  constexpr RelDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RelDefaultTypeInternal() {}
  union {
    Rel _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelDefaultTypeInternal _Rel_default_instance_;
constexpr Expression_Enum_Empty::Expression_Enum_Empty(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct Expression_Enum_EmptyDefaultTypeInternal {
  constexpr Expression_Enum_EmptyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Enum_EmptyDefaultTypeInternal() {}
  union {
    Expression_Enum_Empty _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Enum_EmptyDefaultTypeInternal _Expression_Enum_Empty_default_instance_;
constexpr Expression_Enum::Expression_Enum(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct Expression_EnumDefaultTypeInternal {
  constexpr Expression_EnumDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_EnumDefaultTypeInternal() {}
  union {
    Expression_Enum _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EnumDefaultTypeInternal _Expression_Enum_default_instance_;
constexpr Expression_Literal_VarChar::Expression_Literal_VarChar(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , length_(0u){}
struct Expression_Literal_VarCharDefaultTypeInternal {
  constexpr Expression_Literal_VarCharDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Literal_VarCharDefaultTypeInternal() {}
  union {
    Expression_Literal_VarChar _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_VarCharDefaultTypeInternal _Expression_Literal_VarChar_default_instance_;
constexpr Expression_Literal_Decimal::Expression_Literal_Decimal(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , precision_(0)
  , scale_(0){}
struct Expression_Literal_DecimalDefaultTypeInternal {
  constexpr Expression_Literal_DecimalDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Literal_DecimalDefaultTypeInternal() {}
  union {
    Expression_Literal_Decimal _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_DecimalDefaultTypeInternal _Expression_Literal_Decimal_default_instance_;
constexpr Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : key_(nullptr)
  , value_(nullptr){}
struct Expression_Literal_Map_KeyValueDefaultTypeInternal {
  constexpr Expression_Literal_Map_KeyValueDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Literal_Map_KeyValueDefaultTypeInternal() {}
  union {
    Expression_Literal_Map_KeyValue _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Map_KeyValue_default_instance_;
constexpr Expression_Literal_Map::Expression_Literal_Map(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : key_values_(){}
struct Expression_Literal_MapDefaultTypeInternal {
  constexpr Expression_Literal_MapDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Literal_MapDefaultTypeInternal() {}
  union {
    Expression_Literal_Map _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_MapDefaultTypeInternal _Expression_Literal_Map_default_instance_;
constexpr Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : years_(0)
  , months_(0){}
struct Expression_Literal_IntervalYearToMonthDefaultTypeInternal {
  constexpr Expression_Literal_IntervalYearToMonthDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Literal_IntervalYearToMonthDefaultTypeInternal() {}
  union {
    Expression_Literal_IntervalYearToMonth _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_IntervalYearToMonthDefaultTypeInternal _Expression_Literal_IntervalYearToMonth_default_instance_;
constexpr Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : days_(0)
  , seconds_(0){}
struct Expression_Literal_IntervalDayToSecondDefaultTypeInternal {
  constexpr Expression_Literal_IntervalDayToSecondDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Literal_IntervalDayToSecondDefaultTypeInternal() {}
  union {
    Expression_Literal_IntervalDayToSecond _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_IntervalDayToSecondDefaultTypeInternal _Expression_Literal_IntervalDayToSecond_default_instance_;
constexpr Expression_Literal_Struct::Expression_Literal_Struct(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : fields_(){}
struct Expression_Literal_StructDefaultTypeInternal {
  constexpr Expression_Literal_StructDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Literal_StructDefaultTypeInternal() {}
  union {
    Expression_Literal_Struct _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_;
constexpr Expression_Literal_List::Expression_Literal_List(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : values_(){}
struct Expression_Literal_ListDefaultTypeInternal {
  constexpr Expression_Literal_ListDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Literal_ListDefaultTypeInternal() {}
  union {
    Expression_Literal_List _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_ListDefaultTypeInternal _Expression_Literal_List_default_instance_;
constexpr Expression_Literal::Expression_Literal(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : nullable_(false)
  , _oneof_case_{}{}
struct Expression_LiteralDefaultTypeInternal {
  constexpr Expression_LiteralDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_LiteralDefaultTypeInternal() {}
  union {
    Expression_Literal _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_LiteralDefaultTypeInternal _Expression_Literal_default_instance_;
constexpr Expression_ScalarFunction::Expression_ScalarFunction(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : args_()
  , output_type_(nullptr)
  , function_reference_(0u){}
struct Expression_ScalarFunctionDefaultTypeInternal {
  constexpr Expression_ScalarFunctionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_ScalarFunctionDefaultTypeInternal() {}
  union {
    Expression_ScalarFunction _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_;
constexpr Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : offset_(int64_t{0}){}
struct Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal {
  constexpr Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal() {}
  union {
    Expression_WindowFunction_Bound_Preceding _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal _Expression_WindowFunction_Bound_Preceding_default_instance_;
constexpr Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : offset_(int64_t{0}){}
struct Expression_WindowFunction_Bound_FollowingDefaultTypeInternal {
  constexpr Expression_WindowFunction_Bound_FollowingDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_WindowFunction_Bound_FollowingDefaultTypeInternal() {}
  union {
    Expression_WindowFunction_Bound_Following _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_FollowingDefaultTypeInternal _Expression_WindowFunction_Bound_Following_default_instance_;
constexpr Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal {
  constexpr Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal() {}
  union {
    Expression_WindowFunction_Bound_CurrentRow _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal _Expression_WindowFunction_Bound_CurrentRow_default_instance_;
constexpr Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal {
  constexpr Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal() {}
  union {
    Expression_WindowFunction_Bound_Unbounded _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal _Expression_WindowFunction_Bound_Unbounded_default_instance_;
constexpr Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct Expression_WindowFunction_BoundDefaultTypeInternal {
  constexpr Expression_WindowFunction_BoundDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_WindowFunction_BoundDefaultTypeInternal() {}
  union {
    Expression_WindowFunction_Bound _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_BoundDefaultTypeInternal _Expression_WindowFunction_Bound_default_instance_;
constexpr Expression_WindowFunction::Expression_WindowFunction(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : partitions_()
  , sorts_()
  , args_()
  , upper_bound_(nullptr)
  , lower_bound_(nullptr)
  , output_type_(nullptr)
  , function_reference_(0u)
  , phase_(0)
{}
struct Expression_WindowFunctionDefaultTypeInternal {
  constexpr Expression_WindowFunctionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_WindowFunctionDefaultTypeInternal() {}
  union {
    Expression_WindowFunction _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunctionDefaultTypeInternal _Expression_WindowFunction_default_instance_;
constexpr Expression_IfThen_IfClause::Expression_IfThen_IfClause(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : if__(nullptr)
  , then_(nullptr){}
struct Expression_IfThen_IfClauseDefaultTypeInternal {
  constexpr Expression_IfThen_IfClauseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_IfThen_IfClauseDefaultTypeInternal() {}
  union {
    Expression_IfThen_IfClause _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_IfThen_IfClauseDefaultTypeInternal _Expression_IfThen_IfClause_default_instance_;
constexpr Expression_IfThen::Expression_IfThen(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ifs_()
  , else__(nullptr){}
struct Expression_IfThenDefaultTypeInternal {
  constexpr Expression_IfThenDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_IfThenDefaultTypeInternal() {}
  union {
    Expression_IfThen _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_IfThenDefaultTypeInternal _Expression_IfThen_default_instance_;
constexpr Expression_Cast::Expression_Cast(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : type_(nullptr)
  , input_(nullptr){}
struct Expression_CastDefaultTypeInternal {
  constexpr Expression_CastDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_CastDefaultTypeInternal() {}
  union {
    Expression_Cast _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_CastDefaultTypeInternal _Expression_Cast_default_instance_;
constexpr Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : if__(nullptr)
  , then_(nullptr){}
struct Expression_SwitchExpression_IfValueDefaultTypeInternal {
  constexpr Expression_SwitchExpression_IfValueDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_SwitchExpression_IfValueDefaultTypeInternal() {}
  union {
    Expression_SwitchExpression_IfValue _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SwitchExpression_IfValueDefaultTypeInternal _Expression_SwitchExpression_IfValue_default_instance_;
constexpr Expression_SwitchExpression::Expression_SwitchExpression(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : ifs_()
  , else__(nullptr){}
struct Expression_SwitchExpressionDefaultTypeInternal {
  constexpr Expression_SwitchExpressionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_SwitchExpressionDefaultTypeInternal() {}
  union {
    Expression_SwitchExpression _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SwitchExpressionDefaultTypeInternal _Expression_SwitchExpression_default_instance_;
constexpr Expression_SingularOrList::Expression_SingularOrList(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : options_()
  , value_(nullptr){}
struct Expression_SingularOrListDefaultTypeInternal {
  constexpr Expression_SingularOrListDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_SingularOrListDefaultTypeInternal() {}
  union {
    Expression_SingularOrList _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SingularOrListDefaultTypeInternal _Expression_SingularOrList_default_instance_;
constexpr Expression_MultiOrList_Record::Expression_MultiOrList_Record(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : fields_(){}
struct Expression_MultiOrList_RecordDefaultTypeInternal {
  constexpr Expression_MultiOrList_RecordDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MultiOrList_RecordDefaultTypeInternal() {}
  union {
    Expression_MultiOrList_Record _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MultiOrList_RecordDefaultTypeInternal _Expression_MultiOrList_Record_default_instance_;
constexpr Expression_MultiOrList::Expression_MultiOrList(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : value_()
  , options_(){}
struct Expression_MultiOrListDefaultTypeInternal {
  constexpr Expression_MultiOrListDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MultiOrListDefaultTypeInternal() {}
  union {
    Expression_MultiOrList _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MultiOrListDefaultTypeInternal _Expression_MultiOrList_default_instance_;
constexpr Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : prerequisite_()
  , function_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal {
  constexpr Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal() {}
  union {
    Expression_EmbeddedFunction_PythonPickleFunction _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal _Expression_EmbeddedFunction_PythonPickleFunction_default_instance_;
constexpr Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : prerequisite_()
  , script_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal {
  constexpr Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal() {}
  union {
    Expression_EmbeddedFunction_WebAssemblyFunction _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal _Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_;
constexpr Expression_EmbeddedFunction::Expression_EmbeddedFunction(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : arguments_()
  , output_type_(nullptr)
  , _oneof_case_{}{}
struct Expression_EmbeddedFunctionDefaultTypeInternal {
  constexpr Expression_EmbeddedFunctionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_EmbeddedFunctionDefaultTypeInternal() {}
  union {
    Expression_EmbeddedFunction _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunctionDefaultTypeInternal _Expression_EmbeddedFunction_default_instance_;
constexpr Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : map_key_(nullptr)
  , child_(nullptr){}
struct Expression_ReferenceSegment_MapKeyDefaultTypeInternal {
  constexpr Expression_ReferenceSegment_MapKeyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_ReferenceSegment_MapKeyDefaultTypeInternal() {}
  union {
    Expression_ReferenceSegment_MapKey _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_MapKeyDefaultTypeInternal _Expression_ReferenceSegment_MapKey_default_instance_;
constexpr Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : child_(nullptr)
  , field_(0){}
struct Expression_ReferenceSegment_StructFieldDefaultTypeInternal {
  constexpr Expression_ReferenceSegment_StructFieldDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_ReferenceSegment_StructFieldDefaultTypeInternal() {}
  union {
    Expression_ReferenceSegment_StructField _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_StructFieldDefaultTypeInternal _Expression_ReferenceSegment_StructField_default_instance_;
constexpr Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : child_(nullptr)
  , offset_(0){}
struct Expression_ReferenceSegment_ListElementDefaultTypeInternal {
  constexpr Expression_ReferenceSegment_ListElementDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_ReferenceSegment_ListElementDefaultTypeInternal() {}
  union {
    Expression_ReferenceSegment_ListElement _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_ListElementDefaultTypeInternal _Expression_ReferenceSegment_ListElement_default_instance_;
constexpr Expression_ReferenceSegment::Expression_ReferenceSegment(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct Expression_ReferenceSegmentDefaultTypeInternal {
  constexpr Expression_ReferenceSegmentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_ReferenceSegmentDefaultTypeInternal() {}
  union {
    Expression_ReferenceSegment _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegmentDefaultTypeInternal _Expression_ReferenceSegment_default_instance_;
constexpr Expression_MaskExpression_Select::Expression_MaskExpression_Select(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct Expression_MaskExpression_SelectDefaultTypeInternal {
  constexpr Expression_MaskExpression_SelectDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_SelectDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_Select _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_SelectDefaultTypeInternal _Expression_MaskExpression_Select_default_instance_;
constexpr Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : struct_items_(){}
struct Expression_MaskExpression_StructSelectDefaultTypeInternal {
  constexpr Expression_MaskExpression_StructSelectDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_StructSelectDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_StructSelect _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_StructSelectDefaultTypeInternal _Expression_MaskExpression_StructSelect_default_instance_;
constexpr Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : child_(nullptr)
  , field_(0){}
struct Expression_MaskExpression_StructItemDefaultTypeInternal {
  constexpr Expression_MaskExpression_StructItemDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_StructItemDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_StructItem _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_StructItemDefaultTypeInternal _Expression_MaskExpression_StructItem_default_instance_;
constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : field_(0){}
struct Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal {
  constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_ListSelect_ListSelectItem_ListElement _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_;
constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : start_(0)
  , end_(0){}
struct Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal {
  constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_;
constexpr Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal {
  constexpr Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_ListSelect_ListSelectItem _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_;
constexpr Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : selection_()
  , child_(nullptr){}
struct Expression_MaskExpression_ListSelectDefaultTypeInternal {
  constexpr Expression_MaskExpression_ListSelectDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_ListSelectDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_ListSelect _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelectDefaultTypeInternal _Expression_MaskExpression_ListSelect_default_instance_;
constexpr Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : map_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal {
  constexpr Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_MapSelect_MapKey _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKey_default_instance_;
constexpr Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : map_key_expression_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal {
  constexpr Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_MapSelect_MapKeyExpression _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_;
constexpr Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : child_(nullptr)
  , _oneof_case_{}{}
struct Expression_MaskExpression_MapSelectDefaultTypeInternal {
  constexpr Expression_MaskExpression_MapSelectDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpression_MapSelectDefaultTypeInternal() {}
  union {
    Expression_MaskExpression_MapSelect _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelectDefaultTypeInternal _Expression_MaskExpression_MapSelect_default_instance_;
constexpr Expression_MaskExpression::Expression_MaskExpression(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : select_(nullptr)
  , maintain_singular_struct_(false){}
struct Expression_MaskExpressionDefaultTypeInternal {
  constexpr Expression_MaskExpressionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_MaskExpressionDefaultTypeInternal() {}
  union {
    Expression_MaskExpression _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpressionDefaultTypeInternal _Expression_MaskExpression_default_instance_;
constexpr Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct Expression_FieldReference_RootReferenceDefaultTypeInternal {
  constexpr Expression_FieldReference_RootReferenceDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_FieldReference_RootReferenceDefaultTypeInternal() {}
  union {
    Expression_FieldReference_RootReference _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_FieldReference_RootReferenceDefaultTypeInternal _Expression_FieldReference_RootReference_default_instance_;
constexpr Expression_FieldReference_OuterReference::Expression_FieldReference_OuterReference(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : steps_out_(0u){}
struct Expression_FieldReference_OuterReferenceDefaultTypeInternal {
  constexpr Expression_FieldReference_OuterReferenceDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_FieldReference_OuterReferenceDefaultTypeInternal() {}
  union {
    Expression_FieldReference_OuterReference _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_FieldReference_OuterReferenceDefaultTypeInternal _Expression_FieldReference_OuterReference_default_instance_;
constexpr Expression_FieldReference::Expression_FieldReference(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct Expression_FieldReferenceDefaultTypeInternal {
  constexpr Expression_FieldReferenceDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_FieldReferenceDefaultTypeInternal() {}
  union {
    Expression_FieldReference _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_FieldReferenceDefaultTypeInternal _Expression_FieldReference_default_instance_;
constexpr Expression_Subquery_Scalar::Expression_Subquery_Scalar(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : input_(nullptr){}
struct Expression_Subquery_ScalarDefaultTypeInternal {
  constexpr Expression_Subquery_ScalarDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Subquery_ScalarDefaultTypeInternal() {}
  union {
    Expression_Subquery_Scalar _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Subquery_ScalarDefaultTypeInternal _Expression_Subquery_Scalar_default_instance_;
constexpr Expression_Subquery_InPredicate::Expression_Subquery_InPredicate(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : needles_()
  , haystack_(nullptr){}
struct Expression_Subquery_InPredicateDefaultTypeInternal {
  constexpr Expression_Subquery_InPredicateDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Subquery_InPredicateDefaultTypeInternal() {}
  union {
    Expression_Subquery_InPredicate _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Subquery_InPredicateDefaultTypeInternal _Expression_Subquery_InPredicate_default_instance_;
constexpr Expression_Subquery_SetPredicate::Expression_Subquery_SetPredicate(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : tuples_(nullptr)
  , predicate_op_(0)
{}
struct Expression_Subquery_SetPredicateDefaultTypeInternal {
  constexpr Expression_Subquery_SetPredicateDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Subquery_SetPredicateDefaultTypeInternal() {}
  union {
    Expression_Subquery_SetPredicate _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Subquery_SetPredicateDefaultTypeInternal _Expression_Subquery_SetPredicate_default_instance_;
constexpr Expression_Subquery_SetComparison::Expression_Subquery_SetComparison(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : left_(nullptr)
  , right_(nullptr)
  , reduction_op_(0)

  , comparison_op_(0)
{}
struct Expression_Subquery_SetComparisonDefaultTypeInternal {
  constexpr Expression_Subquery_SetComparisonDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_Subquery_SetComparisonDefaultTypeInternal() {}
  union {
    Expression_Subquery_SetComparison _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Subquery_SetComparisonDefaultTypeInternal _Expression_Subquery_SetComparison_default_instance_;
constexpr Expression_Subquery::Expression_Subquery(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct Expression_SubqueryDefaultTypeInternal {
  constexpr Expression_SubqueryDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Expression_SubqueryDefaultTypeInternal() {}
  union {
    Expression_Subquery _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SubqueryDefaultTypeInternal _Expression_Subquery_default_instance_;
constexpr Expression::Expression(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct ExpressionDefaultTypeInternal {
  constexpr ExpressionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ExpressionDefaultTypeInternal() {}
  union {
    Expression _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExpressionDefaultTypeInternal _Expression_default_instance_;
constexpr SortField::SortField(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : expr_(nullptr)
  , _oneof_case_{}{}
struct SortFieldDefaultTypeInternal {
  constexpr SortFieldDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SortFieldDefaultTypeInternal() {}
  union {
    SortField _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SortFieldDefaultTypeInternal _SortField_default_instance_;
constexpr AggregateFunction::AggregateFunction(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : args_()
  , sorts_()
  , output_type_(nullptr)
  , function_reference_(0u)
  , phase_(0)
{}
struct AggregateFunctionDefaultTypeInternal {
  constexpr AggregateFunctionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AggregateFunctionDefaultTypeInternal() {}
  union {
    AggregateFunction _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateFunctionDefaultTypeInternal _AggregateFunction_default_instance_;
}  // namespace substrait
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2falgebra_2eproto[82];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2falgebra_2eproto[8];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2falgebra_2eproto = nullptr;

const uint32_t TableStruct_substrait_2falgebra_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Direct, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, output_mapping_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, row_count_),
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, record_size_),
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_RuntimeConstraint, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_RuntimeConstraint, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, stats_),
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, constraint_),
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, hint_),
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, advanced_extension_),
  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, emit_kind_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, names_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_VirtualTable, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_VirtualTable, values_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, detail_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _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_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, format_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, partition_index_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, start_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, length_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, path_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, items_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, base_schema_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, filter_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, projection_),
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, advanced_extension_),
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, read_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, input_),
  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, expressions_),
  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, left_),
  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, right_),
  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, expression_),
  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, post_join_filter_),
  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, type_),
  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::CrossRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::CrossRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::CrossRel, left_),
  PROTOBUF_FIELD_OFFSET(::substrait::CrossRel, right_),
  PROTOBUF_FIELD_OFFSET(::substrait::CrossRel, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, input_),
  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, offset_),
  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, count_),
  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Grouping, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Grouping, grouping_expressions_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, measure_),
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, filter_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, input_),
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, groupings_),
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, measures_),
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, input_),
  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, sorts_),
  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, input_),
  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, condition_),
  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, inputs_),
  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, op_),
  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, advanced_extension_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, input_),
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, detail_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, detail_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, common_),
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, inputs_),
  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, detail_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, input_),
  PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, names_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Rel, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Rel, _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_FIELD_OFFSET(::substrait::Rel, rel_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum_Empty, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, enum_kind_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, value_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, length_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, value_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, precision_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, scale_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, key_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, value_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map, key_values_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, years_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, months_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, days_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, seconds_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Struct, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Struct, fields_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, values_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _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_FIELD_OFFSET(::substrait::Expression_Literal, nullable_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, literal_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, function_reference_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, args_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, output_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Preceding, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Preceding, offset_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, offset_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_CurrentRow, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Unbounded, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _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_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, kind_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, function_reference_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, partitions_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, sorts_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, upper_bound_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, lower_bound_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, phase_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, output_type_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, args_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, if__),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, then_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, ifs_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, else__),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, type_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, input_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, if__),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, then_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, ifs_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, else__),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, value_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, options_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList_Record, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList_Record, fields_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, value_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, options_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, function_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, prerequisite_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, script_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, prerequisite_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, arguments_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, output_type_),
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, kind_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, map_key_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, child_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, field_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, child_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, offset_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, child_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, _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_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, reference_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, _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_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructSelect, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructSelect, struct_items_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, field_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, child_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, field_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, selection_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, child_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKey, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKey, map_key_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, map_key_expression_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, child_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, select_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, select_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, maintain_singular_struct_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference_RootReference, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference_OuterReference, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference_OuterReference, steps_out_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _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_FIELD_OFFSET(::substrait::Expression_FieldReference, reference_type_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, root_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_Scalar, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_Scalar, input_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_InPredicate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_InPredicate, needles_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_InPredicate, haystack_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_SetPredicate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_SetPredicate, predicate_op_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_SetPredicate, tuples_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_SetComparison, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_SetComparison, reduction_op_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_SetComparison, comparison_op_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_SetComparison, left_),
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery_SetComparison, right_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Subquery, _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_FIELD_OFFSET(::substrait::Expression_Subquery, subquery_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::Expression, _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_FIELD_OFFSET(::substrait::Expression, rex_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::SortField, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::SortField, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::SortField, expr_),
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::SortField, sort_kind_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, function_reference_),
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, args_),
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, sorts_),
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, phase_),
  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, output_type_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, -1, -1, sizeof(::substrait::RelCommon_Direct)},
  { 6, -1, -1, sizeof(::substrait::RelCommon_Emit)},
  { 13, -1, -1, sizeof(::substrait::RelCommon_Hint_Stats)},
  { 22, -1, -1, sizeof(::substrait::RelCommon_Hint_RuntimeConstraint)},
  { 29, -1, -1, sizeof(::substrait::RelCommon_Hint)},
  { 38, -1, -1, sizeof(::substrait::RelCommon)},
  { 49, -1, -1, sizeof(::substrait::ReadRel_NamedTable)},
  { 57, -1, -1, sizeof(::substrait::ReadRel_VirtualTable)},
  { 64, -1, -1, sizeof(::substrait::ReadRel_ExtensionTable)},
  { 71, -1, -1, sizeof(::substrait::ReadRel_LocalFiles_FileOrFiles)},
  { 86, -1, -1, sizeof(::substrait::ReadRel_LocalFiles)},
  { 94, -1, -1, sizeof(::substrait::ReadRel)},
  { 110, -1, -1, sizeof(::substrait::ProjectRel)},
  { 120, -1, -1, sizeof(::substrait::JoinRel)},
  { 133, -1, -1, sizeof(::substrait::CrossRel)},
  { 143, -1, -1, sizeof(::substrait::FetchRel)},
  { 154, -1, -1, sizeof(::substrait::AggregateRel_Grouping)},
  { 161, -1, -1, sizeof(::substrait::AggregateRel_Measure)},
  { 169, -1, -1, sizeof(::substrait::AggregateRel)},
  { 180, -1, -1, sizeof(::substrait::SortRel)},
  { 190, -1, -1, sizeof(::substrait::FilterRel)},
  { 200, -1, -1, sizeof(::substrait::SetRel)},
  { 210, -1, -1, sizeof(::substrait::ExtensionSingleRel)},
  { 219, -1, -1, sizeof(::substrait::ExtensionLeafRel)},
  { 227, -1, -1, sizeof(::substrait::ExtensionMultiRel)},
  { 236, -1, -1, sizeof(::substrait::RelRoot)},
  { 244, -1, -1, sizeof(::substrait::Rel)},
  { 263, -1, -1, sizeof(::substrait::Expression_Enum_Empty)},
  { 269, -1, -1, sizeof(::substrait::Expression_Enum)},
  { 278, -1, -1, sizeof(::substrait::Expression_Literal_VarChar)},
  { 286, -1, -1, sizeof(::substrait::Expression_Literal_Decimal)},
  { 295, -1, -1, sizeof(::substrait::Expression_Literal_Map_KeyValue)},
  { 303, -1, -1, sizeof(::substrait::Expression_Literal_Map)},
  { 310, -1, -1, sizeof(::substrait::Expression_Literal_IntervalYearToMonth)},
  { 318, -1, -1, sizeof(::substrait::Expression_Literal_IntervalDayToSecond)},
  { 326, -1, -1, sizeof(::substrait::Expression_Literal_Struct)},
  { 333, -1, -1, sizeof(::substrait::Expression_Literal_List)},
  { 340, -1, -1, sizeof(::substrait::Expression_Literal)},
  { 374, -1, -1, sizeof(::substrait::Expression_ScalarFunction)},
  { 383, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Preceding)},
  { 390, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Following)},
  { 397, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_CurrentRow)},
  { 403, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Unbounded)},
  { 409, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound)},
  { 420, -1, -1, sizeof(::substrait::Expression_WindowFunction)},
  { 434, -1, -1, sizeof(::substrait::Expression_IfThen_IfClause)},
  { 442, -1, -1, sizeof(::substrait::Expression_IfThen)},
  { 450, -1, -1, sizeof(::substrait::Expression_Cast)},
  { 458, -1, -1, sizeof(::substrait::Expression_SwitchExpression_IfValue)},
  { 466, -1, -1, sizeof(::substrait::Expression_SwitchExpression)},
  { 474, -1, -1, sizeof(::substrait::Expression_SingularOrList)},
  { 482, -1, -1, sizeof(::substrait::Expression_MultiOrList_Record)},
  { 489, -1, -1, sizeof(::substrait::Expression_MultiOrList)},
  { 497, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction_PythonPickleFunction)},
  { 505, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)},
  { 513, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction)},
  { 524, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_MapKey)},
  { 532, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_StructField)},
  { 540, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_ListElement)},
  { 548, -1, -1, sizeof(::substrait::Expression_ReferenceSegment)},
  { 558, -1, -1, sizeof(::substrait::Expression_MaskExpression_Select)},
  { 568, -1, -1, sizeof(::substrait::Expression_MaskExpression_StructSelect)},
  { 575, -1, -1, sizeof(::substrait::Expression_MaskExpression_StructItem)},
  { 583, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement)},
  { 590, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice)},
  { 598, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem)},
  { 607, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect)},
  { 615, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKey)},
  { 622, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression)},
  { 629, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect)},
  { 639, -1, -1, sizeof(::substrait::Expression_MaskExpression)},
  { 647, -1, -1, sizeof(::substrait::Expression_FieldReference_RootReference)},
  { 653, -1, -1, sizeof(::substrait::Expression_FieldReference_OuterReference)},
  { 660, -1, -1, sizeof(::substrait::Expression_FieldReference)},
  { 673, -1, -1, sizeof(::substrait::Expression_Subquery_Scalar)},
  { 680, -1, -1, sizeof(::substrait::Expression_Subquery_InPredicate)},
  { 688, -1, -1, sizeof(::substrait::Expression_Subquery_SetPredicate)},
  { 696, -1, -1, sizeof(::substrait::Expression_Subquery_SetComparison)},
  { 706, -1, -1, sizeof(::substrait::Expression_Subquery)},
  { 717, -1, -1, sizeof(::substrait::Expression)},
  { 735, -1, -1, sizeof(::substrait::SortField)},
  { 745, -1, -1, sizeof(::substrait::AggregateFunction)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Direct_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Emit_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Hint_Stats_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Hint_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_NamedTable_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_VirtualTable_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_ExtensionTable_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_LocalFiles_FileOrFiles_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_LocalFiles_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ProjectRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_JoinRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_CrossRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FetchRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_AggregateRel_Grouping_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_AggregateRel_Measure_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_AggregateRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_SortRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FilterRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_SetRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ExtensionSingleRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ExtensionLeafRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ExtensionMultiRel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelRoot_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Rel_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Enum_Empty_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Enum_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_VarChar_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_Decimal_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_Map_KeyValue_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_Map_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_Struct_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_List_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ScalarFunction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_Following_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_IfThen_IfClause_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_IfThen_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Cast_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_SwitchExpression_IfValue_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_SwitchExpression_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_SingularOrList_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MultiOrList_Record_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MultiOrList_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_EmbeddedFunction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ReferenceSegment_MapKey_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ReferenceSegment_StructField_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ReferenceSegment_ListElement_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ReferenceSegment_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_Select_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_StructSelect_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_StructItem_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_ListSelect_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_MapSelect_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_FieldReference_RootReference_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_FieldReference_OuterReference_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_FieldReference_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Subquery_Scalar_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Subquery_InPredicate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Subquery_SetPredicate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Subquery_SetComparison_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Subquery_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_SortField_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_AggregateFunction_default_instance_),
};

const char descriptor_table_protodef_substrait_2falgebra_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\027substrait/algebra.proto\022\tsubstrait\032\024su"
  "bstrait/type.proto\032%substrait/extensions"
  "/extensions.proto\032\031google/protobuf/any.p"
  "roto\"\262\006\n\tRelCommon\0225\n\006direct\030\001 \001(\0132\033.sub"
  "strait.RelCommon.DirectH\000R\006direct\022/\n\004emi"
  "t\030\002 \001(\0132\031.substrait.RelCommon.EmitH\000R\004em"
  "it\022-\n\004hint\030\003 \001(\0132\031.substrait.RelCommon.H"
  "intR\004hint\022V\n\022advanced_extension\030\004 \001(\0132\'."
  "substrait.extensions.AdvancedExtensionR\021"
  "advancedExtension\032\010\n\006Direct\032-\n\004Emit\022%\n\016o"
  "utput_mapping\030\001 \003(\005R\routputMapping\032\357\003\n\004H"
  "int\0225\n\005stats\030\001 \001(\0132\037.substrait.RelCommon"
  ".Hint.StatsR\005stats\022K\n\nconstraint\030\002 \001(\0132+"
  ".substrait.RelCommon.Hint.RuntimeConstra"
  "intR\nconstraint\022V\n\022advanced_extension\030\n "
  "\001(\0132\'.substrait.extensions.AdvancedExten"
  "sionR\021advancedExtension\032\235\001\n\005Stats\022\033\n\trow"
  "_count\030\001 \001(\001R\010rowCount\022\037\n\013record_size\030\002 "
  "\001(\001R\nrecordSize\022V\n\022advanced_extension\030\n "
  "\001(\0132\'.substrait.extensions.AdvancedExten"
  "sionR\021advancedExtension\032k\n\021RuntimeConstr"
  "aint\022V\n\022advanced_extension\030\n \001(\0132\'.subst"
  "rait.extensions.AdvancedExtensionR\021advan"
  "cedExtensionB\013\n\temit_kind\"\235\013\n\007ReadRel\022,\n"
  "\006common\030\001 \001(\0132\024.substrait.RelCommonR\006com"
  "mon\0227\n\013base_schema\030\002 \001(\0132\026.substrait.Nam"
  "edStructR\nbaseSchema\022-\n\006filter\030\003 \001(\0132\025.s"
  "ubstrait.ExpressionR\006filter\022D\n\nprojectio"
  "n\030\004 \001(\0132$.substrait.Expression.MaskExpre"
  "ssionR\nprojection\022V\n\022advanced_extension\030"
  "\n \001(\0132\'.substrait.extensions.AdvancedExt"
  "ensionR\021advancedExtension\022F\n\rvirtual_tab"
  "le\030\005 \001(\0132\037.substrait.ReadRel.VirtualTabl"
  "eH\000R\014virtualTable\022@\n\013local_files\030\006 \001(\0132\035"
  ".substrait.ReadRel.LocalFilesH\000R\nlocalFi"
  "les\022@\n\013named_table\030\007 \001(\0132\035.substrait.Rea"
  "dRel.NamedTableH\000R\nnamedTable\022L\n\017extensi"
  "on_table\030\010 \001(\0132!.substrait.ReadRel.Exten"
  "sionTableH\000R\016extensionTable\032z\n\nNamedTabl"
  "e\022\024\n\005names\030\001 \003(\tR\005names\022V\n\022advanced_exte"
  "nsion\030\n \001(\0132\'.substrait.extensions.Advan"
  "cedExtensionR\021advancedExtension\032L\n\014Virtu"
  "alTable\022<\n\006values\030\001 \003(\0132$.substrait.Expr"
  "ession.Literal.StructR\006values\032>\n\016Extensi"
  "onTable\022,\n\006detail\030\001 \001(\0132\024.google.protobu"
  "f.AnyR\006detail\032\254\004\n\nLocalFiles\022\?\n\005items\030\001 "
  "\003(\0132).substrait.ReadRel.LocalFiles.FileO"
  "rFilesR\005items\022V\n\022advanced_extension\030\n \001("
  "\0132\'.substrait.extensions.AdvancedExtensi"
  "onR\021advancedExtension\032\204\003\n\013FileOrFiles\022\033\n"
  "\010uri_path\030\001 \001(\tH\000R\007uriPath\022$\n\ruri_path_g"
  "lob\030\002 \001(\tH\000R\013uriPathGlob\022\033\n\010uri_file\030\003 \001"
  "(\tH\000R\007uriFile\022\037\n\nuri_folder\030\004 \001(\tH\000R\turi"
  "Folder\022L\n\006format\030\005 \001(\01624.substrait.ReadR"
  "el.LocalFiles.FileOrFiles.FileFormatR\006fo"
  "rmat\022\'\n\017partition_index\030\006 \001(\004R\016partition"
  "Index\022\024\n\005start\030\007 \001(\004R\005start\022\026\n\006length\030\010 "
  "\001(\004R\006length\"B\n\nFileFormat\022\033\n\027FILE_FORMAT"
  "_UNSPECIFIED\020\000\022\027\n\023FILE_FORMAT_PARQUET\020\001B"
  "\013\n\tpath_typeB\013\n\tread_type\"\361\001\n\nProjectRel"
  "\022,\n\006common\030\001 \001(\0132\024.substrait.RelCommonR\006"
  "common\022$\n\005input\030\002 \001(\0132\016.substrait.RelR\005i"
  "nput\0227\n\013expressions\030\003 \003(\0132\025.substrait.Ex"
  "pressionR\013expressions\022V\n\022advanced_extens"
  "ion\030\n \001(\0132\'.substrait.extensions.Advance"
  "dExtensionR\021advancedExtension\"\273\004\n\007JoinRe"
  "l\022,\n\006common\030\001 \001(\0132\024.substrait.RelCommonR"
  "\006common\022\"\n\004left\030\002 \001(\0132\016.substrait.RelR\004l"
  "eft\022$\n\005right\030\003 \001(\0132\016.substrait.RelR\005righ"
  "t\0225\n\nexpression\030\004 \001(\0132\025.substrait.Expres"
  "sionR\nexpression\022\?\n\020post_join_filter\030\005 \001"
  "(\0132\025.substrait.ExpressionR\016postJoinFilte"
  "r\022/\n\004type\030\006 \001(\0162\033.substrait.JoinRel.Join"
  "TypeR\004type\022V\n\022advanced_extension\030\n \001(\0132\'"
  ".substrait.extensions.AdvancedExtensionR"
  "\021advancedExtension\"\266\001\n\010JoinType\022\031\n\025JOIN_"
  "TYPE_UNSPECIFIED\020\000\022\023\n\017JOIN_TYPE_INNER\020\001\022"
  "\023\n\017JOIN_TYPE_OUTER\020\002\022\022\n\016JOIN_TYPE_LEFT\020\003"
  "\022\023\n\017JOIN_TYPE_RIGHT\020\004\022\022\n\016JOIN_TYPE_SEMI\020"
  "\005\022\022\n\016JOIN_TYPE_ANTI\020\006\022\024\n\020JOIN_TYPE_SINGL"
  "E\020\007\"\332\001\n\010CrossRel\022,\n\006common\030\001 \001(\0132\024.subst"
  "rait.RelCommonR\006common\022\"\n\004left\030\002 \001(\0132\016.s"
  "ubstrait.RelR\004left\022$\n\005right\030\003 \001(\0132\016.subs"
  "trait.RelR\005right\022V\n\022advanced_extension\030\n"
  " \001(\0132\'.substrait.extensions.AdvancedExte"
  "nsionR\021advancedExtension\"\344\001\n\010FetchRel\022,\n"
  "\006common\030\001 \001(\0132\024.substrait.RelCommonR\006com"
  "mon\022$\n\005input\030\002 \001(\0132\016.substrait.RelR\005inpu"
  "t\022\026\n\006offset\030\003 \001(\003R\006offset\022\024\n\005count\030\004 \001(\003"
  "R\005count\022V\n\022advanced_extension\030\n \001(\0132\'.su"
  "bstrait.extensions.AdvancedExtensionR\021ad"
  "vancedExtension\"\377\003\n\014AggregateRel\022,\n\006comm"
  "on\030\001 \001(\0132\024.substrait.RelCommonR\006common\022$"
  "\n\005input\030\002 \001(\0132\016.substrait.RelR\005input\022>\n\t"
  "groupings\030\003 \003(\0132 .substrait.AggregateRel"
  ".GroupingR\tgroupings\022;\n\010measures\030\004 \003(\0132\037"
  ".substrait.AggregateRel.MeasureR\010measure"
  "s\022V\n\022advanced_extension\030\n \001(\0132\'.substrai"
  "t.extensions.AdvancedExtensionR\021advanced"
  "Extension\032T\n\010Grouping\022H\n\024grouping_expres"
  "sions\030\001 \003(\0132\025.substrait.ExpressionR\023grou"
  "pingExpressions\032p\n\007Measure\0226\n\007measure\030\001 "
  "\001(\0132\034.substrait.AggregateFunctionR\007measu"
  "re\022-\n\006filter\030\002 \001(\0132\025.substrait.Expressio"
  "nR\006filter\"\341\001\n\007SortRel\022,\n\006common\030\001 \001(\0132\024."
  "substrait.RelCommonR\006common\022$\n\005input\030\002 \001"
  "(\0132\016.substrait.RelR\005input\022*\n\005sorts\030\003 \003(\013"
  "2\024.substrait.SortFieldR\005sorts\022V\n\022advance"
  "d_extension\030\n \001(\0132\'.substrait.extensions"
  ".AdvancedExtensionR\021advancedExtension\"\354\001"
  "\n\tFilterRel\022,\n\006common\030\001 \001(\0132\024.substrait."
  "RelCommonR\006common\022$\n\005input\030\002 \001(\0132\016.subst"
  "rait.RelR\005input\0223\n\tcondition\030\003 \001(\0132\025.sub"
  "strait.ExpressionR\tcondition\022V\n\022advanced"
  "_extension\030\n \001(\0132\'.substrait.extensions."
  "AdvancedExtensionR\021advancedExtension\"\252\003\n"
  "\006SetRel\022,\n\006common\030\001 \001(\0132\024.substrait.RelC"
  "ommonR\006common\022&\n\006inputs\030\002 \003(\0132\016.substrai"
  "t.RelR\006inputs\022\'\n\002op\030\003 \001(\0162\027.substrait.Se"
  "tRel.SetOpR\002op\022V\n\022advanced_extension\030\n \001"
  "(\0132\'.substrait.extensions.AdvancedExtens"
  "ionR\021advancedExtension\"\310\001\n\005SetOp\022\026\n\022SET_"
  "OP_UNSPECIFIED\020\000\022\030\n\024SET_OP_MINUS_PRIMARY"
  "\020\001\022\031\n\025SET_OP_MINUS_MULTISET\020\002\022\037\n\033SET_OP_"
  "INTERSECTION_PRIMARY\020\003\022 \n\034SET_OP_INTERSE"
  "CTION_MULTISET\020\004\022\031\n\025SET_OP_UNION_DISTINC"
  "T\020\005\022\024\n\020SET_OP_UNION_ALL\020\006\"\226\001\n\022ExtensionS"
  "ingleRel\022,\n\006common\030\001 \001(\0132\024.substrait.Rel"
  "CommonR\006common\022$\n\005input\030\002 \001(\0132\016.substrai"
  "t.RelR\005input\022,\n\006detail\030\003 \001(\0132\024.google.pr"
  "otobuf.AnyR\006detail\"n\n\020ExtensionLeafRel\022,"
  "\n\006common\030\001 \001(\0132\024.substrait.RelCommonR\006co"
  "mmon\022,\n\006detail\030\002 \001(\0132\024.google.protobuf.A"
  "nyR\006detail\"\227\001\n\021ExtensionMultiRel\022,\n\006comm"
  "on\030\001 \001(\0132\024.substrait.RelCommonR\006common\022&"
  "\n\006inputs\030\002 \003(\0132\016.substrait.RelR\006inputs\022,"
  "\n\006detail\030\003 \001(\0132\024.google.protobuf.AnyR\006de"
  "tail\"E\n\007RelRoot\022$\n\005input\030\001 \001(\0132\016.substra"
  "it.RelR\005input\022\024\n\005names\030\002 \003(\tR\005names\"\207\005\n\003"
  "Rel\022(\n\004read\030\001 \001(\0132\022.substrait.ReadRelH\000R"
  "\004read\022.\n\006filter\030\002 \001(\0132\024.substrait.Filter"
  "RelH\000R\006filter\022+\n\005fetch\030\003 \001(\0132\023.substrait"
  ".FetchRelH\000R\005fetch\0227\n\taggregate\030\004 \001(\0132\027."
  "substrait.AggregateRelH\000R\taggregate\022(\n\004s"
  "ort\030\005 \001(\0132\022.substrait.SortRelH\000R\004sort\022(\n"
  "\004join\030\006 \001(\0132\022.substrait.JoinRelH\000R\004join\022"
  "1\n\007project\030\007 \001(\0132\025.substrait.ProjectRelH"
  "\000R\007project\022%\n\003set\030\010 \001(\0132\021.substrait.SetR"
  "elH\000R\003set\022J\n\020extension_single\030\t \001(\0132\035.su"
  "bstrait.ExtensionSingleRelH\000R\017extensionS"
  "ingle\022G\n\017extension_multi\030\n \001(\0132\034.substra"
  "it.ExtensionMultiRelH\000R\016extensionMulti\022D"
  "\n\016extension_leaf\030\013 \001(\0132\033.substrait.Exten"
  "sionLeafRelH\000R\rextensionLeaf\022+\n\005cross\030\014 "
  "\001(\0132\023.substrait.CrossRelH\000R\005crossB\n\n\010rel"
  "_type\"\236F\n\nExpression\0229\n\007literal\030\001 \001(\0132\035."
  "substrait.Expression.LiteralH\000R\007literal\022"
  "D\n\tselection\030\002 \001(\0132$.substrait.Expressio"
  "n.FieldReferenceH\000R\tselection\022O\n\017scalar_"
  "function\030\003 \001(\0132$.substrait.Expression.Sc"
  "alarFunctionH\000R\016scalarFunction\022O\n\017window"
  "_function\030\005 \001(\0132$.substrait.Expression.W"
  "indowFunctionH\000R\016windowFunction\0227\n\007if_th"
  "en\030\006 \001(\0132\034.substrait.Expression.IfThenH\000"
  "R\006ifThen\022U\n\021switch_expression\030\007 \001(\0132&.su"
  "bstrait.Expression.SwitchExpressionH\000R\020s"
  "witchExpression\022P\n\020singular_or_list\030\010 \001("
  "\0132$.substrait.Expression.SingularOrListH"
  "\000R\016singularOrList\022G\n\rmulti_or_list\030\t \001(\013"
  "2!.substrait.Expression.MultiOrListH\000R\013m"
  "ultiOrList\0220\n\004enum\030\n \001(\0132\032.substrait.Exp"
  "ression.EnumH\000R\004enum\0220\n\004cast\030\013 \001(\0132\032.sub"
  "strait.Expression.CastH\000R\004cast\022<\n\010subque"
  "ry\030\014 \001(\0132\036.substrait.Expression.Subquery"
  "H\000R\010subquery\032\202\001\n\004Enum\022\036\n\tspecified\030\001 \001(\t"
  "H\000R\tspecified\022D\n\013unspecified\030\002 \001(\0132 .sub"
  "strait.Expression.Enum.EmptyH\000R\013unspecif"
  "ied\032\007\n\005EmptyB\013\n\tenum_kind\032\307\r\n\007Literal\022\032\n"
  "\007boolean\030\001 \001(\010H\000R\007boolean\022\020\n\002i8\030\002 \001(\005H\000R"
  "\002i8\022\022\n\003i16\030\003 \001(\005H\000R\003i16\022\022\n\003i32\030\005 \001(\005H\000R\003"
  "i32\022\022\n\003i64\030\007 \001(\003H\000R\003i64\022\024\n\004fp32\030\n \001(\002H\000R"
  "\004fp32\022\024\n\004fp64\030\013 \001(\001H\000R\004fp64\022\030\n\006string\030\014 "
  "\001(\tH\000R\006string\022\030\n\006binary\030\r \001(\014H\000R\006binary\022"
  "\036\n\ttimestamp\030\016 \001(\003H\000R\ttimestamp\022\024\n\004date\030"
  "\020 \001(\005H\000R\004date\022\024\n\004time\030\021 \001(\003H\000R\004time\022h\n\026i"
  "nterval_year_to_month\030\023 \001(\01321.substrait."
  "Expression.Literal.IntervalYearToMonthH\000"
  "R\023intervalYearToMonth\022h\n\026interval_day_to"
  "_second\030\024 \001(\01321.substrait.Expression.Lit"
  "eral.IntervalDayToSecondH\000R\023intervalDayT"
  "oSecond\022\037\n\nfixed_char\030\025 \001(\tH\000R\tfixedChar"
  "\022B\n\010var_char\030\026 \001(\0132%.substrait.Expressio"
  "n.Literal.VarCharH\000R\007varChar\022#\n\014fixed_bi"
  "nary\030\027 \001(\014H\000R\013fixedBinary\022A\n\007decimal\030\030 \001"
  "(\0132%.substrait.Expression.Literal.Decima"
  "lH\000R\007decimal\022>\n\006struct\030\031 \001(\0132$.substrait"
  ".Expression.Literal.StructH\000R\006struct\0225\n\003"
  "map\030\032 \001(\0132!.substrait.Expression.Literal"
  ".MapH\000R\003map\022#\n\014timestamp_tz\030\033 \001(\003H\000R\013tim"
  "estampTz\022\024\n\004uuid\030\034 \001(\014H\000R\004uuid\022%\n\004null\030\035"
  " \001(\0132\017.substrait.TypeH\000R\004null\0228\n\004list\030\036 "
  "\001(\0132\".substrait.Expression.Literal.ListH"
  "\000R\004list\0225\n\nempty_list\030\037 \001(\0132\024.substrait."
  "Type.ListH\000R\temptyList\0222\n\tempty_map\030  \001("
  "\0132\023.substrait.Type.MapH\000R\010emptyMap\022\032\n\010nu"
  "llable\0302 \001(\010R\010nullable\0327\n\007VarChar\022\024\n\005val"
  "ue\030\001 \001(\tR\005value\022\026\n\006length\030\002 \001(\rR\006length\032"
  "S\n\007Decimal\022\024\n\005value\030\001 \001(\014R\005value\022\034\n\tprec"
  "ision\030\002 \001(\005R\tprecision\022\024\n\005scale\030\003 \001(\005R\005s"
  "cale\032\302\001\n\003Map\022I\n\nkey_values\030\001 \003(\0132*.subst"
  "rait.Expression.Literal.Map.KeyValueR\tke"
  "yValues\032p\n\010KeyValue\022/\n\003key\030\001 \001(\0132\035.subst"
  "rait.Expression.LiteralR\003key\0223\n\005value\030\002 "
  "\001(\0132\035.substrait.Expression.LiteralR\005valu"
  "e\032C\n\023IntervalYearToMonth\022\024\n\005years\030\001 \001(\005R"
  "\005years\022\026\n\006months\030\002 \001(\005R\006months\032C\n\023Interv"
  "alDayToSecond\022\022\n\004days\030\001 \001(\005R\004days\022\030\n\007sec"
  "onds\030\002 \001(\005R\007seconds\032\?\n\006Struct\0225\n\006fields\030"
  "\001 \003(\0132\035.substrait.Expression.LiteralR\006fi"
  "elds\032=\n\004List\0225\n\006values\030\001 \003(\0132\035.substrait"
  ".Expression.LiteralR\006valuesB\016\n\014literal_t"
  "ype\032\234\001\n\016ScalarFunction\022-\n\022function_refer"
  "ence\030\001 \001(\rR\021functionReference\022)\n\004args\030\002 "
  "\003(\0132\025.substrait.ExpressionR\004args\0220\n\013outp"
  "ut_type\030\003 \001(\0132\017.substrait.TypeR\noutputTy"
  "pe\032\237\007\n\016WindowFunction\022-\n\022function_refere"
  "nce\030\001 \001(\rR\021functionReference\0225\n\npartitio"
  "ns\030\002 \003(\0132\025.substrait.ExpressionR\npartiti"
  "ons\022*\n\005sorts\030\003 \003(\0132\024.substrait.SortField"
  "R\005sorts\022K\n\013upper_bound\030\004 \001(\0132*.substrait"
  ".Expression.WindowFunction.BoundR\nupperB"
  "ound\022K\n\013lower_bound\030\005 \001(\0132*.substrait.Ex"
  "pression.WindowFunction.BoundR\nlowerBoun"
  "d\0221\n\005phase\030\006 \001(\0162\033.substrait.Aggregation"
  "PhaseR\005phase\0220\n\013output_type\030\007 \001(\0132\017.subs"
  "trait.TypeR\noutputType\022)\n\004args\030\010 \003(\0132\025.s"
  "ubstrait.ExpressionR\004args\032\320\003\n\005Bound\022T\n\tp"
  "receding\030\001 \001(\01324.substrait.Expression.Wi"
  "ndowFunction.Bound.PrecedingH\000R\tprecedin"
  "g\022T\n\tfollowing\030\002 \001(\01324.substrait.Express"
  "ion.WindowFunction.Bound.FollowingH\000R\tfo"
  "llowing\022X\n\013current_row\030\003 \001(\01325.substrait"
  ".Expression.WindowFunction.Bound.Current"
  "RowH\000R\ncurrentRow\022T\n\tunbounded\030\004 \001(\01324.s"
  "ubstrait.Expression.WindowFunction.Bound"
  ".UnboundedH\000R\tunbounded\032#\n\tPreceding\022\026\n\006"
  "offset\030\001 \001(\003R\006offset\032#\n\tFollowing\022\026\n\006off"
  "set\030\001 \001(\003R\006offset\032\014\n\nCurrentRow\032\013\n\tUnbou"
  "ndedB\006\n\004kind\032\312\001\n\006IfThen\0227\n\003ifs\030\001 \003(\0132%.s"
  "ubstrait.Expression.IfThen.IfClauseR\003ifs"
  "\022)\n\004else\030\002 \001(\0132\025.substrait.ExpressionR\004e"
  "lse\032\\\n\010IfClause\022%\n\002if\030\001 \001(\0132\025.substrait."
  "ExpressionR\002if\022)\n\004then\030\002 \001(\0132\025.substrait"
  ".ExpressionR\004then\032X\n\004Cast\022#\n\004type\030\001 \001(\0132"
  "\017.substrait.TypeR\004type\022+\n\005input\030\002 \001(\0132\025."
  "substrait.ExpressionR\005input\032\344\001\n\020SwitchEx"
  "pression\022@\n\003ifs\030\001 \003(\0132..substrait.Expres"
  "sion.SwitchExpression.IfValueR\003ifs\022)\n\004el"
  "se\030\002 \001(\0132\025.substrait.ExpressionR\004else\032c\n"
  "\007IfValue\022-\n\002if\030\001 \001(\0132\035.substrait.Express"
  "ion.LiteralR\002if\022)\n\004then\030\002 \001(\0132\025.substrai"
  "t.ExpressionR\004then\032n\n\016SingularOrList\022+\n\005"
  "value\030\001 \001(\0132\025.substrait.ExpressionR\005valu"
  "e\022/\n\007options\030\002 \003(\0132\025.substrait.Expressio"
  "nR\007options\032\267\001\n\013MultiOrList\022+\n\005value\030\001 \003("
  "\0132\025.substrait.ExpressionR\005value\022B\n\007optio"
  "ns\030\002 \003(\0132(.substrait.Expression.MultiOrL"
  "ist.RecordR\007options\0327\n\006Record\022-\n\006fields\030"
  "\001 \003(\0132\025.substrait.ExpressionR\006fields\032\223\004\n"
  "\020EmbeddedFunction\0223\n\targuments\030\001 \003(\0132\025.s"
  "ubstrait.ExpressionR\targuments\0220\n\013output"
  "_type\030\002 \001(\0132\017.substrait.TypeR\noutputType"
  "\022s\n\026python_pickle_function\030\003 \001(\0132;.subst"
  "rait.Expression.EmbeddedFunction.PythonP"
  "ickleFunctionH\000R\024pythonPickleFunction\022p\n"
  "\025web_assembly_function\030\004 \001(\0132:.substrait"
  ".Expression.EmbeddedFunction.WebAssembly"
  "FunctionH\000R\023webAssemblyFunction\032V\n\024Pytho"
  "nPickleFunction\022\032\n\010function\030\001 \001(\014R\010funct"
  "ion\022\"\n\014prerequisite\030\002 \003(\tR\014prerequisite\032"
  "Q\n\023WebAssemblyFunction\022\026\n\006script\030\001 \001(\014R\006"
  "script\022\"\n\014prerequisite\030\002 \003(\tR\014prerequisi"
  "teB\006\n\004kind\032\350\004\n\020ReferenceSegment\022H\n\007map_k"
  "ey\030\001 \001(\0132-.substrait.Expression.Referenc"
  "eSegment.MapKeyH\000R\006mapKey\022W\n\014struct_fiel"
  "d\030\002 \001(\01322.substrait.Expression.Reference"
  "Segment.StructFieldH\000R\013structField\022W\n\014li"
  "st_element\030\003 \001(\01322.substrait.Expression."
  "ReferenceSegment.ListElementH\000R\013listElem"
  "ent\032~\n\006MapKey\0226\n\007map_key\030\001 \001(\0132\035.substra"
  "it.Expression.LiteralR\006mapKey\022<\n\005child\030\002"
  " \001(\0132&.substrait.Expression.ReferenceSeg"
  "mentR\005child\032a\n\013StructField\022\024\n\005field\030\001 \001("
  "\005R\005field\022<\n\005child\030\002 \001(\0132&.substrait.Expr"
  "ession.ReferenceSegmentR\005child\032c\n\013ListEl"
  "ement\022\026\n\006offset\030\001 \001(\005R\006offset\022<\n\005child\030\002"
  " \001(\0132&.substrait.Expression.ReferenceSeg"
  "mentR\005childB\020\n\016reference_type\032\242\013\n\016MaskEx"
  "pression\022I\n\006select\030\001 \001(\01321.substrait.Exp"
  "ression.MaskExpression.StructSelectR\006sel"
  "ect\0228\n\030maintain_singular_struct\030\002 \001(\010R\026m"
  "aintainSingularStruct\032\350\001\n\006Select\022K\n\006stru"
  "ct\030\001 \001(\01321.substrait.Expression.MaskExpr"
  "ession.StructSelectH\000R\006struct\022E\n\004list\030\002 "
  "\001(\0132/.substrait.Expression.MaskExpressio"
  "n.ListSelectH\000R\004list\022B\n\003map\030\003 \001(\0132..subs"
  "trait.Expression.MaskExpression.MapSelec"
  "tH\000R\003mapB\006\n\004type\032b\n\014StructSelect\022R\n\014stru"
  "ct_items\030\001 \003(\0132/.substrait.Expression.Ma"
  "skExpression.StructItemR\013structItems\032e\n\n"
  "StructItem\022\024\n\005field\030\001 \001(\005R\005field\022A\n\005chil"
  "d\030\002 \001(\0132+.substrait.Expression.MaskExpre"
  "ssion.SelectR\005child\032\346\003\n\nListSelect\022\\\n\tse"
  "lection\030\001 \003(\0132>.substrait.Expression.Mas"
  "kExpression.ListSelect.ListSelectItemR\ts"
  "election\022A\n\005child\030\002 \001(\0132+.substrait.Expr"
  "ession.MaskExpression.SelectR\005child\032\266\002\n\016"
  "ListSelectItem\022`\n\004item\030\001 \001(\0132J.substrait"
  ".Expression.MaskExpression.ListSelect.Li"
  "stSelectItem.ListElementH\000R\004item\022`\n\005slic"
  "e\030\002 \001(\0132H.substrait.Expression.MaskExpre"
  "ssion.ListSelect.ListSelectItem.ListSlic"
  "eH\000R\005slice\032#\n\013ListElement\022\024\n\005field\030\001 \001(\005"
  "R\005field\0323\n\tListSlice\022\024\n\005start\030\001 \001(\005R\005sta"
  "rt\022\020\n\003end\030\002 \001(\005R\003endB\006\n\004type\032\353\002\n\tMapSele"
  "ct\022I\n\003key\030\001 \001(\01325.substrait.Expression.M"
  "askExpression.MapSelect.MapKeyH\000R\003key\022a\n"
  "\nexpression\030\002 \001(\0132\?.substrait.Expression"
  ".MaskExpression.MapSelect.MapKeyExpressi"
  "onH\000R\nexpression\022A\n\005child\030\003 \001(\0132+.substr"
  "ait.Expression.MaskExpression.SelectR\005ch"
  "ild\032!\n\006MapKey\022\027\n\007map_key\030\001 \001(\tR\006mapKey\032@"
  "\n\020MapKeyExpression\022,\n\022map_key_expression"
  "\030\001 \001(\tR\020mapKeyExpressionB\010\n\006select\032\215\004\n\016F"
  "ieldReference\022S\n\020direct_reference\030\001 \001(\0132"
  "&.substrait.Expression.ReferenceSegmentH"
  "\000R\017directReference\022Q\n\020masked_reference\030\002"
  " \001(\0132$.substrait.Expression.MaskExpressi"
  "onH\000R\017maskedReference\0227\n\nexpression\030\003 \001("
  "\0132\025.substrait.ExpressionH\001R\nexpression\022["
  "\n\016root_reference\030\004 \001(\01322.substrait.Expre"
  "ssion.FieldReference.RootReferenceH\001R\rro"
  "otReference\022^\n\017outer_reference\030\005 \001(\01323.s"
  "ubstrait.Expression.FieldReference.Outer"
  "ReferenceH\001R\016outerReference\032\017\n\rRootRefer"
  "ence\032-\n\016OuterReference\022\033\n\tsteps_out\030\001 \001("
  "\rR\010stepsOutB\020\n\016reference_typeB\013\n\troot_ty"
  "pe\032\225\n\n\010Subquery\022\?\n\006scalar\030\001 \001(\0132%.substr"
  "ait.Expression.Subquery.ScalarH\000R\006scalar"
  "\022O\n\014in_predicate\030\002 \001(\0132*.substrait.Expre"
  "ssion.Subquery.InPredicateH\000R\013inPredicat"
  "e\022R\n\rset_predicate\030\003 \001(\0132+.substrait.Exp"
  "ression.Subquery.SetPredicateH\000R\014setPred"
  "icate\022U\n\016set_comparison\030\004 \001(\0132,.substrai"
  "t.Expression.Subquery.SetComparisonH\000R\rs"
  "etComparison\032.\n\006Scalar\022$\n\005input\030\001 \001(\0132\016."
  "substrait.RelR\005input\032j\n\013InPredicate\022/\n\007n"
  "eedles\030\001 \003(\0132\025.substrait.ExpressionR\007nee"
  "dles\022*\n\010haystack\030\002 \001(\0132\016.substrait.RelR\010"
  "haystack\032\361\001\n\014SetPredicate\022Z\n\014predicate_o"
  "p\030\001 \001(\01627.substrait.Expression.Subquery."
  "SetPredicate.PredicateOpR\013predicateOp\022&\n"
  "\006tuples\030\002 \001(\0132\016.substrait.RelR\006tuples\"]\n"
  "\013PredicateOp\022\034\n\030PREDICATE_OP_UNSPECIFIED"
  "\020\000\022\027\n\023PREDICATE_OP_EXISTS\020\001\022\027\n\023PREDICATE"
  "_OP_UNIQUE\020\002\032\252\004\n\rSetComparison\022[\n\014reduct"
  "ion_op\030\001 \001(\01628.substrait.Expression.Subq"
  "uery.SetComparison.ReductionOpR\013reductio"
  "nOp\022^\n\rcomparison_op\030\002 \001(\01629.substrait.E"
  "xpression.Subquery.SetComparison.Compari"
  "sonOpR\014comparisonOp\022)\n\004left\030\003 \001(\0132\025.subs"
  "trait.ExpressionR\004left\022$\n\005right\030\004 \001(\0132\016."
  "substrait.RelR\005right\"\261\001\n\014ComparisonOp\022\035\n"
  "\031COMPARISON_OP_UNSPECIFIED\020\000\022\024\n\020COMPARIS"
  "ON_OP_EQ\020\001\022\024\n\020COMPARISON_OP_NE\020\002\022\024\n\020COMP"
  "ARISON_OP_LT\020\003\022\024\n\020COMPARISON_OP_GT\020\004\022\024\n\020"
  "COMPARISON_OP_LE\020\005\022\024\n\020COMPARISON_OP_GE\020\006"
  "\"W\n\013ReductionOp\022\034\n\030REDUCTION_OP_UNSPECIF"
  "IED\020\000\022\024\n\020REDUCTION_OP_ANY\020\001\022\024\n\020REDUCTION"
  "_OP_ALL\020\002B\017\n\rsubquery_typeB\n\n\010rex_type\"\255"
  "\003\n\tSortField\022)\n\004expr\030\001 \001(\0132\025.substrait.E"
  "xpressionR\004expr\022B\n\tdirection\030\002 \001(\0162\".sub"
  "strait.SortField.SortDirectionH\000R\tdirect"
  "ion\022D\n\035comparison_function_reference\030\003 \001"
  "(\rH\000R\033comparisonFunctionReference\"\335\001\n\rSo"
  "rtDirection\022\036\n\032SORT_DIRECTION_UNSPECIFIE"
  "D\020\000\022\"\n\036SORT_DIRECTION_ASC_NULLS_FIRST\020\001\022"
  "!\n\035SORT_DIRECTION_ASC_NULLS_LAST\020\002\022#\n\037SO"
  "RT_DIRECTION_DESC_NULLS_FIRST\020\003\022\"\n\036SORT_"
  "DIRECTION_DESC_NULLS_LAST\020\004\022\034\n\030SORT_DIRE"
  "CTION_CLUSTERED\020\005B\013\n\tsort_kind\"\376\001\n\021Aggre"
  "gateFunction\022-\n\022function_reference\030\001 \001(\r"
  "R\021functionReference\022)\n\004args\030\002 \003(\0132\025.subs"
  "trait.ExpressionR\004args\022*\n\005sorts\030\003 \003(\0132\024."
  "substrait.SortFieldR\005sorts\0221\n\005phase\030\004 \001("
  "\0162\033.substrait.AggregationPhaseR\005phase\0220\n"
  "\013output_type\030\005 \001(\0132\017.substrait.TypeR\nout"
  "putType*\357\001\n\020AggregationPhase\022!\n\035AGGREGAT"
  "ION_PHASE_UNSPECIFIED\020\000\022-\n)AGGREGATION_P"
  "HASE_INITIAL_TO_INTERMEDIATE\020\001\0222\n.AGGREG"
  "ATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE"
  "\020\002\022\'\n#AGGREGATION_PHASE_INITIAL_TO_RESUL"
  "T\020\003\022,\n(AGGREGATION_PHASE_INTERMEDIATE_TO"
  "_RESULT\020\004B+\n\022io.substrait.protoP\001\252\002\022Subs"
  "trait.Protobufb\006proto3"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2falgebra_2eproto_deps[3] = {
  &::descriptor_table_google_2fprotobuf_2fany_2eproto,
  &::descriptor_table_substrait_2fextensions_2fextensions_2eproto,
  &::descriptor_table_substrait_2ftype_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2falgebra_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2falgebra_2eproto = {
  false, false, 16182, descriptor_table_protodef_substrait_2falgebra_2eproto, "substrait/algebra.proto", 
  &descriptor_table_substrait_2falgebra_2eproto_once, descriptor_table_substrait_2falgebra_2eproto_deps, 3, 82,
  schemas, file_default_instances, TableStruct_substrait_2falgebra_2eproto::offsets,
  file_level_metadata_substrait_2falgebra_2eproto, file_level_enum_descriptors_substrait_2falgebra_2eproto, file_level_service_descriptors_substrait_2falgebra_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2falgebra_2eproto_getter() {
  return &descriptor_table_substrait_2falgebra_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2falgebra_2eproto(&descriptor_table_substrait_2falgebra_2eproto);
namespace substrait {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2falgebra_2eproto);
  return file_level_enum_descriptors_substrait_2falgebra_2eproto[0];
}
bool ReadRel_LocalFiles_FileOrFiles_FileFormat_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 ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_UNSPECIFIED;
constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_PARQUET;
constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MIN;
constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MAX;
constexpr int ReadRel_LocalFiles_FileOrFiles::FileFormat_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2falgebra_2eproto);
  return file_level_enum_descriptors_substrait_2falgebra_2eproto[1];
}
bool JoinRel_JoinType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_UNSPECIFIED;
constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_INNER;
constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_OUTER;
constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_LEFT;
constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_RIGHT;
constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_SEMI;
constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_ANTI;
constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_SINGLE;
constexpr JoinRel_JoinType JoinRel::JoinType_MIN;
constexpr JoinRel_JoinType JoinRel::JoinType_MAX;
constexpr int JoinRel::JoinType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2falgebra_2eproto);
  return file_level_enum_descriptors_substrait_2falgebra_2eproto[2];
}
bool SetRel_SetOp_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SetRel_SetOp SetRel::SET_OP_UNSPECIFIED;
constexpr SetRel_SetOp SetRel::SET_OP_MINUS_PRIMARY;
constexpr SetRel_SetOp SetRel::SET_OP_MINUS_MULTISET;
constexpr SetRel_SetOp SetRel::SET_OP_INTERSECTION_PRIMARY;
constexpr SetRel_SetOp SetRel::SET_OP_INTERSECTION_MULTISET;
constexpr SetRel_SetOp SetRel::SET_OP_UNION_DISTINCT;
constexpr SetRel_SetOp SetRel::SET_OP_UNION_ALL;
constexpr SetRel_SetOp SetRel::SetOp_MIN;
constexpr SetRel_SetOp SetRel::SetOp_MAX;
constexpr int SetRel::SetOp_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_Subquery_SetPredicate_PredicateOp_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2falgebra_2eproto);
  return file_level_enum_descriptors_substrait_2falgebra_2eproto[3];
}
bool Expression_Subquery_SetPredicate_PredicateOp_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr Expression_Subquery_SetPredicate_PredicateOp Expression_Subquery_SetPredicate::PREDICATE_OP_UNSPECIFIED;
constexpr Expression_Subquery_SetPredicate_PredicateOp Expression_Subquery_SetPredicate::PREDICATE_OP_EXISTS;
constexpr Expression_Subquery_SetPredicate_PredicateOp Expression_Subquery_SetPredicate::PREDICATE_OP_UNIQUE;
constexpr Expression_Subquery_SetPredicate_PredicateOp Expression_Subquery_SetPredicate::PredicateOp_MIN;
constexpr Expression_Subquery_SetPredicate_PredicateOp Expression_Subquery_SetPredicate::PredicateOp_MAX;
constexpr int Expression_Subquery_SetPredicate::PredicateOp_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_Subquery_SetComparison_ComparisonOp_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2falgebra_2eproto);
  return file_level_enum_descriptors_substrait_2falgebra_2eproto[4];
}
bool Expression_Subquery_SetComparison_ComparisonOp_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr Expression_Subquery_SetComparison_ComparisonOp Expression_Subquery_SetComparison::COMPARISON_OP_UNSPECIFIED;
constexpr Expression_Subquery_SetComparison_ComparisonOp Expression_Subquery_SetComparison::COMPARISON_OP_EQ;
constexpr Expression_Subquery_SetComparison_ComparisonOp Expression_Subquery_SetComparison::COMPARISON_OP_NE;
constexpr Expression_Subquery_SetComparison_ComparisonOp Expression_Subquery_SetComparison::COMPARISON_OP_LT;
constexpr Expression_Subquery_SetComparison_ComparisonOp Expression_Subquery_SetComparison::COMPARISON_OP_GT;
constexpr Expression_Subquery_SetComparison_ComparisonOp Expression_Subquery_SetComparison::COMPARISON_OP_LE;
constexpr Expression_Subquery_SetComparison_ComparisonOp Expression_Subquery_SetComparison::COMPARISON_OP_GE;
constexpr Expression_Subquery_SetComparison_ComparisonOp Expression_Subquery_SetComparison::ComparisonOp_MIN;
constexpr Expression_Subquery_SetComparison_ComparisonOp Expression_Subquery_SetComparison::ComparisonOp_MAX;
constexpr int Expression_Subquery_SetComparison::ComparisonOp_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_Subquery_SetComparison_ReductionOp_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2falgebra_2eproto);
  return file_level_enum_descriptors_substrait_2falgebra_2eproto[5];
}
bool Expression_Subquery_SetComparison_ReductionOp_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr Expression_Subquery_SetComparison_ReductionOp Expression_Subquery_SetComparison::REDUCTION_OP_UNSPECIFIED;
constexpr Expression_Subquery_SetComparison_ReductionOp Expression_Subquery_SetComparison::REDUCTION_OP_ANY;
constexpr Expression_Subquery_SetComparison_ReductionOp Expression_Subquery_SetComparison::REDUCTION_OP_ALL;
constexpr Expression_Subquery_SetComparison_ReductionOp Expression_Subquery_SetComparison::ReductionOp_MIN;
constexpr Expression_Subquery_SetComparison_ReductionOp Expression_Subquery_SetComparison::ReductionOp_MAX;
constexpr int Expression_Subquery_SetComparison::ReductionOp_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortField_SortDirection_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2falgebra_2eproto);
  return file_level_enum_descriptors_substrait_2falgebra_2eproto[6];
}
bool SortField_SortDirection_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SortField_SortDirection SortField::SORT_DIRECTION_UNSPECIFIED;
constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_FIRST;
constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_LAST;
constexpr SortField_SortDirection SortField::SORT_DIRECTION_DESC_NULLS_FIRST;
constexpr SortField_SortDirection SortField::SORT_DIRECTION_DESC_NULLS_LAST;
constexpr SortField_SortDirection SortField::SORT_DIRECTION_CLUSTERED;
constexpr SortField_SortDirection SortField::SortDirection_MIN;
constexpr SortField_SortDirection SortField::SortDirection_MAX;
constexpr int SortField::SortDirection_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2falgebra_2eproto);
  return file_level_enum_descriptors_substrait_2falgebra_2eproto[7];
}
bool AggregationPhase_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}


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

class RelCommon_Direct::_Internal {
 public:
};

RelCommon_Direct::RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Direct)
}
RelCommon_Direct::RelCommon_Direct(const RelCommon_Direct& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Direct)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Direct::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Direct::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Direct::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[0]);
}

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

class RelCommon_Emit::_Internal {
 public:
};

RelCommon_Emit::RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  output_mapping_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Emit)
}
RelCommon_Emit::RelCommon_Emit(const RelCommon_Emit& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      output_mapping_(from.output_mapping_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Emit)
}

inline void RelCommon_Emit::SharedCtor() {
}

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

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

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

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

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

const char* RelCommon_Emit::_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 int32 output_mapping = 1 [json_name = "outputMapping"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_output_mapping(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<uint8_t>(tag) == 8) {
          _internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* RelCommon_Emit::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Emit)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 output_mapping = 1 [json_name = "outputMapping"];
  {
    int byte_size = _output_mapping_cached_byte_size_.load(std::memory_order_relaxed);
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(
          1, _internal_output_mapping(), byte_size, 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.RelCommon.Emit)
  return target;
}

size_t RelCommon_Emit::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Emit)
  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 int32 output_mapping = 1 [json_name = "outputMapping"];
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->output_mapping_);
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<int32_t>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _output_mapping_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  output_mapping_.MergeFrom(from.output_mapping_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void RelCommon_Emit::InternalSwap(RelCommon_Emit* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  output_mapping_.InternalSwap(&other->output_mapping_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Emit::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[1]);
}

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

class RelCommon_Hint_Stats::_Internal {
 public:
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_Stats* msg);
};

const ::substrait::extensions::AdvancedExtension&
RelCommon_Hint_Stats::_Internal::advanced_extension(const RelCommon_Hint_Stats* msg) {
  return *msg->advanced_extension_;
}
void RelCommon_Hint_Stats::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
RelCommon_Hint_Stats::RelCommon_Hint_Stats(::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.RelCommon.Hint.Stats)
}
RelCommon_Hint_Stats::RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  ::memcpy(&row_count_, &from.row_count_,
    static_cast<size_t>(reinterpret_cast<char*>(&record_size_) -
    reinterpret_cast<char*>(&row_count_)) + sizeof(record_size_));
  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.Stats)
}

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

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

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

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

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

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

const char* RelCommon_Hint_Stats::_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) {
      // double row_count = 1 [json_name = "rowCount"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
          row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // double record_size = 2 [json_name = "recordSize"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          record_size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* RelCommon_Hint_Stats::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.Stats)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // double row_count = 1 [json_name = "rowCount"];
  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
  double tmp_row_count = this->_internal_row_count();
  uint64_t raw_row_count;
  memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count));
  if (raw_row_count != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_row_count(), target);
  }

  // double record_size = 2 [json_name = "recordSize"];
  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
  double tmp_record_size = this->_internal_record_size();
  uint64_t raw_record_size;
  memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size));
  if (raw_record_size != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_record_size(), target);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.RelCommon.Hint.Stats)
  return target;
}

size_t RelCommon_Hint_Stats::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.Stats)
  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.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  // double row_count = 1 [json_name = "rowCount"];
  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
  double tmp_row_count = this->_internal_row_count();
  uint64_t raw_row_count;
  memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count));
  if (raw_row_count != 0) {
    total_size += 1 + 8;
  }

  // double record_size = 2 [json_name = "recordSize"];
  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
  double tmp_record_size = this->_internal_record_size();
  uint64_t raw_record_size;
  memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size));
  if (raw_record_size != 0) {
    total_size += 1 + 8;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
  double tmp_row_count = from._internal_row_count();
  uint64_t raw_row_count;
  memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count));
  if (raw_row_count != 0) {
    _internal_set_row_count(from._internal_row_count());
  }
  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
  double tmp_record_size = from._internal_record_size();
  uint64_t raw_record_size;
  memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size));
  if (raw_record_size != 0) {
    _internal_set_record_size(from._internal_record_size());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_Stats::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[2]);
}

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

class RelCommon_Hint_RuntimeConstraint::_Internal {
 public:
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg);
};

const ::substrait::extensions::AdvancedExtension&
RelCommon_Hint_RuntimeConstraint::_Internal::advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg) {
  return *msg->advanced_extension_;
}
void RelCommon_Hint_RuntimeConstraint::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(::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.RelCommon.Hint.RuntimeConstraint)
}
RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(const RelCommon_Hint_RuntimeConstraint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.RuntimeConstraint)
}

inline void RelCommon_Hint_RuntimeConstraint::SharedCtor() {
advanced_extension_ = nullptr;
}

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

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

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

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

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

const char* RelCommon_Hint_RuntimeConstraint::_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.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* RelCommon_Hint_RuntimeConstraint::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.RuntimeConstraint)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.RelCommon.Hint.RuntimeConstraint)
  return target;
}

size_t RelCommon_Hint_RuntimeConstraint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.RuntimeConstraint)
  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.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void RelCommon_Hint_RuntimeConstraint::InternalSwap(RelCommon_Hint_RuntimeConstraint* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(advanced_extension_, other->advanced_extension_);
}

::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_RuntimeConstraint::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[3]);
}

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

class RelCommon_Hint::_Internal {
 public:
  static const ::substrait::RelCommon_Hint_Stats& stats(const RelCommon_Hint* msg);
  static const ::substrait::RelCommon_Hint_RuntimeConstraint& constraint(const RelCommon_Hint* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint* msg);
};

const ::substrait::RelCommon_Hint_Stats&
RelCommon_Hint::_Internal::stats(const RelCommon_Hint* msg) {
  return *msg->stats_;
}
const ::substrait::RelCommon_Hint_RuntimeConstraint&
RelCommon_Hint::_Internal::constraint(const RelCommon_Hint* msg) {
  return *msg->constraint_;
}
const ::substrait::extensions::AdvancedExtension&
RelCommon_Hint::_Internal::advanced_extension(const RelCommon_Hint* msg) {
  return *msg->advanced_extension_;
}
void RelCommon_Hint::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
RelCommon_Hint::RelCommon_Hint(::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.RelCommon.Hint)
}
RelCommon_Hint::RelCommon_Hint(const RelCommon_Hint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_stats()) {
    stats_ = new ::substrait::RelCommon_Hint_Stats(*from.stats_);
  } else {
    stats_ = nullptr;
  }
  if (from._internal_has_constraint()) {
    constraint_ = new ::substrait::RelCommon_Hint_RuntimeConstraint(*from.constraint_);
  } else {
    constraint_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint)
}

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

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

inline void RelCommon_Hint::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete stats_;
  if (this != internal_default_instance()) delete constraint_;
  if (this != internal_default_instance()) delete advanced_extension_;
}

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

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

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

const char* RelCommon_Hint::_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.RelCommon.Hint.Stats stats = 1 [json_name = "stats"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2 [json_name = "constraint"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_constraint(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* RelCommon_Hint::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.RelCommon.Hint.Stats stats = 1 [json_name = "stats"];
  if (this->_internal_has_stats()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::stats(this), target, stream);
  }

  // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2 [json_name = "constraint"];
  if (this->_internal_has_constraint()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::constraint(this), target, stream);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.RelCommon.Hint)
  return target;
}

size_t RelCommon_Hint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint)
  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.RelCommon.Hint.Stats stats = 1 [json_name = "stats"];
  if (this->_internal_has_stats()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *stats_);
  }

  // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2 [json_name = "constraint"];
  if (this->_internal_has_constraint()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *constraint_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_stats()) {
    _internal_mutable_stats()->::substrait::RelCommon_Hint_Stats::MergeFrom(from._internal_stats());
  }
  if (from._internal_has_constraint()) {
    _internal_mutable_constraint()->::substrait::RelCommon_Hint_RuntimeConstraint::MergeFrom(from._internal_constraint());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[4]);
}

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

class RelCommon::_Internal {
 public:
  static const ::substrait::RelCommon_Direct& direct(const RelCommon* msg);
  static const ::substrait::RelCommon_Emit& emit(const RelCommon* msg);
  static const ::substrait::RelCommon_Hint& hint(const RelCommon* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon* msg);
};

const ::substrait::RelCommon_Direct&
RelCommon::_Internal::direct(const RelCommon* msg) {
  return *msg->emit_kind_.direct_;
}
const ::substrait::RelCommon_Emit&
RelCommon::_Internal::emit(const RelCommon* msg) {
  return *msg->emit_kind_.emit_;
}
const ::substrait::RelCommon_Hint&
RelCommon::_Internal::hint(const RelCommon* msg) {
  return *msg->hint_;
}
const ::substrait::extensions::AdvancedExtension&
RelCommon::_Internal::advanced_extension(const RelCommon* msg) {
  return *msg->advanced_extension_;
}
void RelCommon::set_allocated_direct(::substrait::RelCommon_Direct* direct) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_emit_kind();
  if (direct) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Direct>::GetOwningArena(direct);
    if (message_arena != submessage_arena) {
      direct = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, direct, submessage_arena);
    }
    set_has_direct();
    emit_kind_.direct_ = direct;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.direct)
}
void RelCommon::set_allocated_emit(::substrait::RelCommon_Emit* emit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_emit_kind();
  if (emit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Emit>::GetOwningArena(emit);
    if (message_arena != submessage_arena) {
      emit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, emit, submessage_arena);
    }
    set_has_emit();
    emit_kind_.emit_ = emit;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.emit)
}
void RelCommon::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
RelCommon::RelCommon(::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.RelCommon)
}
RelCommon::RelCommon(const RelCommon& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_hint()) {
    hint_ = new ::substrait::RelCommon_Hint(*from.hint_);
  } else {
    hint_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  clear_has_emit_kind();
  switch (from.emit_kind_case()) {
    case kDirect: {
      _internal_mutable_direct()->::substrait::RelCommon_Direct::MergeFrom(from._internal_direct());
      break;
    }
    case kEmit: {
      _internal_mutable_emit()->::substrait::RelCommon_Emit::MergeFrom(from._internal_emit());
      break;
    }
    case EMIT_KIND_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon)
}

inline void RelCommon::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&hint_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&advanced_extension_) -
    reinterpret_cast<char*>(&hint_)) + sizeof(advanced_extension_));
clear_has_emit_kind();
}

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

inline void RelCommon::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete hint_;
  if (this != internal_default_instance()) delete advanced_extension_;
  if (has_emit_kind()) {
    clear_emit_kind();
  }
}

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

void RelCommon::clear_emit_kind() {
// @@protoc_insertion_point(one_of_clear_start:substrait.RelCommon)
  switch (emit_kind_case()) {
    case kDirect: {
      if (GetArenaForAllocation() == nullptr) {
        delete emit_kind_.direct_;
      }
      break;
    }
    case kEmit: {
      if (GetArenaForAllocation() == nullptr) {
        delete emit_kind_.emit_;
      }
      break;
    }
    case EMIT_KIND_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EMIT_KIND_NOT_SET;
}


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

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

const char* RelCommon::_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.RelCommon.Direct direct = 1 [json_name = "direct"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_direct(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.RelCommon.Emit emit = 2 [json_name = "emit"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_emit(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.RelCommon.Hint hint = 3 [json_name = "hint"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_hint(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 4 [json_name = "advancedExtension"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* RelCommon::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  // .substrait.extensions.AdvancedExtension advanced_extension = 4 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::advanced_extension(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.RelCommon)
  return target;
}

size_t RelCommon::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon)
  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.RelCommon.Hint hint = 3 [json_name = "hint"];
  if (this->_internal_has_hint()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *hint_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 4 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  switch (emit_kind_case()) {
    // .substrait.RelCommon.Direct direct = 1 [json_name = "direct"];
    case kDirect: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *emit_kind_.direct_);
      break;
    }
    // .substrait.RelCommon.Emit emit = 2 [json_name = "emit"];
    case kEmit: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *emit_kind_.emit_);
      break;
    }
    case EMIT_KIND_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_hint()) {
    _internal_mutable_hint()->::substrait::RelCommon_Hint::MergeFrom(from._internal_hint());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  switch (from.emit_kind_case()) {
    case kDirect: {
      _internal_mutable_direct()->::substrait::RelCommon_Direct::MergeFrom(from._internal_direct());
      break;
    }
    case kEmit: {
      _internal_mutable_emit()->::substrait::RelCommon_Emit::MergeFrom(from._internal_emit());
      break;
    }
    case EMIT_KIND_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void RelCommon::InternalSwap(RelCommon* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RelCommon, advanced_extension_)
      + sizeof(RelCommon::advanced_extension_)
      - PROTOBUF_FIELD_OFFSET(RelCommon, hint_)>(
          reinterpret_cast<char*>(&hint_),
          reinterpret_cast<char*>(&other->hint_));
  swap(emit_kind_, other->emit_kind_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata RelCommon::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[5]);
}

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

class ReadRel_NamedTable::_Internal {
 public:
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_NamedTable* msg);
};

const ::substrait::extensions::AdvancedExtension&
ReadRel_NamedTable::_Internal::advanced_extension(const ReadRel_NamedTable* msg) {
  return *msg->advanced_extension_;
}
void ReadRel_NamedTable::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
ReadRel_NamedTable::ReadRel_NamedTable(::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.ReadRel.NamedTable)
}
ReadRel_NamedTable::ReadRel_NamedTable(const ReadRel_NamedTable& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      names_(from.names_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.NamedTable)
}

inline void ReadRel_NamedTable::SharedCtor() {
advanced_extension_ = nullptr;
}

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

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

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

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

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

const char* ReadRel_NamedTable::_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.ReadRel.NamedTable.names"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* ReadRel_NamedTable::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.NamedTable)
  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.ReadRel.NamedTable.names");
    target = stream->WriteString(1, s, target);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.ReadRel.NamedTable)
  return target;
}

size_t ReadRel_NamedTable::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.NamedTable)
  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.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  names_.MergeFrom(from.names_);
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_NamedTable::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[6]);
}

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

class ReadRel_VirtualTable::_Internal {
 public:
};

ReadRel_VirtualTable::ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  values_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.VirtualTable)
}
ReadRel_VirtualTable::ReadRel_VirtualTable(const ReadRel_VirtualTable& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      values_(from.values_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.VirtualTable)
}

inline void ReadRel_VirtualTable::SharedCtor() {
}

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

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

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

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

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

const char* ReadRel_VirtualTable::_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.Expression.Literal.Struct values = 1 [json_name = "values"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_values(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* ReadRel_VirtualTable::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.VirtualTable)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression.Literal.Struct values = 1 [json_name = "values"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_values_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_values(i), 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.ReadRel.VirtualTable)
  return target;
}

size_t ReadRel_VirtualTable::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.VirtualTable)
  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.Expression.Literal.Struct values = 1 [json_name = "values"];
  total_size += 1UL * this->_internal_values_size();
  for (const auto& msg : this->values_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  values_.MergeFrom(from.values_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void ReadRel_VirtualTable::InternalSwap(ReadRel_VirtualTable* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  values_.InternalSwap(&other->values_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_VirtualTable::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[7]);
}

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

class ReadRel_ExtensionTable::_Internal {
 public:
  static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ReadRel_ExtensionTable* msg);
};

const ::PROTOBUF_NAMESPACE_ID::Any&
ReadRel_ExtensionTable::_Internal::detail(const ReadRel_ExtensionTable* msg) {
  return *msg->detail_;
}
void ReadRel_ExtensionTable::clear_detail() {
  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
    delete detail_;
  }
  detail_ = nullptr;
}
ReadRel_ExtensionTable::ReadRel_ExtensionTable(::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.ReadRel.ExtensionTable)
}
ReadRel_ExtensionTable::ReadRel_ExtensionTable(const ReadRel_ExtensionTable& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_detail()) {
    detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_);
  } else {
    detail_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.ExtensionTable)
}

inline void ReadRel_ExtensionTable::SharedCtor() {
detail_ = nullptr;
}

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

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

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

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

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

const char* ReadRel_ExtensionTable::_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) {
      // .google.protobuf.Any detail = 1 [json_name = "detail"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_detail(), 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* ReadRel_ExtensionTable::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.ExtensionTable)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .google.protobuf.Any detail = 1 [json_name = "detail"];
  if (this->_internal_has_detail()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::detail(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.ReadRel.ExtensionTable)
  return target;
}

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

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

  // .google.protobuf.Any detail = 1 [json_name = "detail"];
  if (this->_internal_has_detail()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *detail_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_detail()) {
    _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void ReadRel_ExtensionTable::InternalSwap(ReadRel_ExtensionTable* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(detail_, other->detail_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_ExtensionTable::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[8]);
}

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

class ReadRel_LocalFiles_FileOrFiles::_Internal {
 public:
};

ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(::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.ReadRel.LocalFiles.FileOrFiles)
}
ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&format_, &from.format_,
    static_cast<size_t>(reinterpret_cast<char*>(&length_) -
    reinterpret_cast<char*>(&format_)) + sizeof(length_));
  clear_has_path_type();
  switch (from.path_type_case()) {
    case kUriPath: {
      _internal_set_uri_path(from._internal_uri_path());
      break;
    }
    case kUriPathGlob: {
      _internal_set_uri_path_glob(from._internal_uri_path_glob());
      break;
    }
    case kUriFile: {
      _internal_set_uri_file(from._internal_uri_file());
      break;
    }
    case kUriFolder: {
      _internal_set_uri_folder(from._internal_uri_folder());
      break;
    }
    case PATH_TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles.FileOrFiles)
}

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

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

inline void ReadRel_LocalFiles_FileOrFiles::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_path_type()) {
    clear_path_type();
  }
}

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

void ReadRel_LocalFiles_FileOrFiles::clear_path_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel.LocalFiles.FileOrFiles)
  switch (path_type_case()) {
    case kUriPath: {
      path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kUriPathGlob: {
      path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kUriFile: {
      path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kUriFolder: {
      path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case PATH_TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = PATH_TYPE_NOT_SET;
}


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

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

const char* ReadRel_LocalFiles_FileOrFiles::_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 uri_path = 1 [json_name = "uriPath"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_uri_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string uri_path_glob = 2 [json_name = "uriPathGlob"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_uri_path_glob();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string uri_file = 3 [json_name = "uriFile"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_uri_file();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_file"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string uri_folder = 4 [json_name = "uriFolder"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_uri_folder();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5 [json_name = "format"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_format(static_cast<::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat>(val));
        } else
          goto handle_unusual;
        continue;
      // uint64 partition_index = 6 [json_name = "partitionIndex"];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          partition_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 start = 7 [json_name = "start"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 length = 8 [json_name = "length"];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&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* ReadRel_LocalFiles_FileOrFiles::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles.FileOrFiles)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string uri_path = 1 [json_name = "uriPath"];
  if (_internal_has_uri_path()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_uri_path().data(), static_cast<int>(this->_internal_uri_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_uri_path(), target);
  }

  // string uri_path_glob = 2 [json_name = "uriPathGlob"];
  if (_internal_has_uri_path_glob()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_uri_path_glob().data(), static_cast<int>(this->_internal_uri_path_glob().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_uri_path_glob(), target);
  }

  // string uri_file = 3 [json_name = "uriFile"];
  if (_internal_has_uri_file()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_uri_file().data(), static_cast<int>(this->_internal_uri_file().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.ReadRel.LocalFiles.FileOrFiles.uri_file");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_uri_file(), target);
  }

  // string uri_folder = 4 [json_name = "uriFolder"];
  if (_internal_has_uri_folder()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_uri_folder().data(), static_cast<int>(this->_internal_uri_folder().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_uri_folder(), target);
  }

  // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5 [json_name = "format"];
  if (this->_internal_format() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      5, this->_internal_format(), target);
  }

  // uint64 partition_index = 6 [json_name = "partitionIndex"];
  if (this->_internal_partition_index() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->_internal_partition_index(), target);
  }

  // uint64 start = 7 [json_name = "start"];
  if (this->_internal_start() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(7, this->_internal_start(), target);
  }

  // uint64 length = 8 [json_name = "length"];
  if (this->_internal_length() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->_internal_length(), 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.ReadRel.LocalFiles.FileOrFiles)
  return target;
}

size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles.FileOrFiles)
  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.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5 [json_name = "format"];
  if (this->_internal_format() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_format());
  }

  // uint64 partition_index = 6 [json_name = "partitionIndex"];
  if (this->_internal_partition_index() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_partition_index());
  }

  // uint64 start = 7 [json_name = "start"];
  if (this->_internal_start() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_start());
  }

  // uint64 length = 8 [json_name = "length"];
  if (this->_internal_length() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_length());
  }

  switch (path_type_case()) {
    // string uri_path = 1 [json_name = "uriPath"];
    case kUriPath: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_uri_path());
      break;
    }
    // string uri_path_glob = 2 [json_name = "uriPathGlob"];
    case kUriPathGlob: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_uri_path_glob());
      break;
    }
    // string uri_file = 3 [json_name = "uriFile"];
    case kUriFile: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_uri_file());
      break;
    }
    // string uri_folder = 4 [json_name = "uriFolder"];
    case kUriFolder: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_uri_folder());
      break;
    }
    case PATH_TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_format() != 0) {
    _internal_set_format(from._internal_format());
  }
  if (from._internal_partition_index() != 0) {
    _internal_set_partition_index(from._internal_partition_index());
  }
  if (from._internal_start() != 0) {
    _internal_set_start(from._internal_start());
  }
  if (from._internal_length() != 0) {
    _internal_set_length(from._internal_length());
  }
  switch (from.path_type_case()) {
    case kUriPath: {
      _internal_set_uri_path(from._internal_uri_path());
      break;
    }
    case kUriPathGlob: {
      _internal_set_uri_path_glob(from._internal_uri_path_glob());
      break;
    }
    case kUriFile: {
      _internal_set_uri_file(from._internal_uri_file());
      break;
    }
    case kUriFolder: {
      _internal_set_uri_folder(from._internal_uri_folder());
      break;
    }
    case PATH_TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void ReadRel_LocalFiles_FileOrFiles::InternalSwap(ReadRel_LocalFiles_FileOrFiles* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ReadRel_LocalFiles_FileOrFiles, length_)
      + sizeof(ReadRel_LocalFiles_FileOrFiles::length_)
      - PROTOBUF_FIELD_OFFSET(ReadRel_LocalFiles_FileOrFiles, format_)>(
          reinterpret_cast<char*>(&format_),
          reinterpret_cast<char*>(&other->format_));
  swap(path_type_, other->path_type_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles_FileOrFiles::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[9]);
}

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

class ReadRel_LocalFiles::_Internal {
 public:
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_LocalFiles* msg);
};

const ::substrait::extensions::AdvancedExtension&
ReadRel_LocalFiles::_Internal::advanced_extension(const ReadRel_LocalFiles* msg) {
  return *msg->advanced_extension_;
}
void ReadRel_LocalFiles::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
ReadRel_LocalFiles::ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  items_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.LocalFiles)
}
ReadRel_LocalFiles::ReadRel_LocalFiles(const ReadRel_LocalFiles& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      items_(from.items_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles)
}

inline void ReadRel_LocalFiles::SharedCtor() {
advanced_extension_ = nullptr;
}

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

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

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

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

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

const char* ReadRel_LocalFiles::_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.ReadRel.LocalFiles.FileOrFiles items = 1 [json_name = "items"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_items(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* ReadRel_LocalFiles::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1 [json_name = "items"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_items_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_items(i), target, stream);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.ReadRel.LocalFiles)
  return target;
}

size_t ReadRel_LocalFiles::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles)
  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.ReadRel.LocalFiles.FileOrFiles items = 1 [json_name = "items"];
  total_size += 1UL * this->_internal_items_size();
  for (const auto& msg : this->items_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  items_.MergeFrom(from.items_);
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void ReadRel_LocalFiles::InternalSwap(ReadRel_LocalFiles* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  items_.InternalSwap(&other->items_);
  swap(advanced_extension_, other->advanced_extension_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[10]);
}

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

class ReadRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const ReadRel* msg);
  static const ::substrait::NamedStruct& base_schema(const ReadRel* msg);
  static const ::substrait::Expression& filter(const ReadRel* msg);
  static const ::substrait::Expression_MaskExpression& projection(const ReadRel* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel* msg);
  static const ::substrait::ReadRel_VirtualTable& virtual_table(const ReadRel* msg);
  static const ::substrait::ReadRel_LocalFiles& local_files(const ReadRel* msg);
  static const ::substrait::ReadRel_NamedTable& named_table(const ReadRel* msg);
  static const ::substrait::ReadRel_ExtensionTable& extension_table(const ReadRel* msg);
};

const ::substrait::RelCommon&
ReadRel::_Internal::common(const ReadRel* msg) {
  return *msg->common_;
}
const ::substrait::NamedStruct&
ReadRel::_Internal::base_schema(const ReadRel* msg) {
  return *msg->base_schema_;
}
const ::substrait::Expression&
ReadRel::_Internal::filter(const ReadRel* msg) {
  return *msg->filter_;
}
const ::substrait::Expression_MaskExpression&
ReadRel::_Internal::projection(const ReadRel* msg) {
  return *msg->projection_;
}
const ::substrait::extensions::AdvancedExtension&
ReadRel::_Internal::advanced_extension(const ReadRel* msg) {
  return *msg->advanced_extension_;
}
const ::substrait::ReadRel_VirtualTable&
ReadRel::_Internal::virtual_table(const ReadRel* msg) {
  return *msg->read_type_.virtual_table_;
}
const ::substrait::ReadRel_LocalFiles&
ReadRel::_Internal::local_files(const ReadRel* msg) {
  return *msg->read_type_.local_files_;
}
const ::substrait::ReadRel_NamedTable&
ReadRel::_Internal::named_table(const ReadRel* msg) {
  return *msg->read_type_.named_table_;
}
const ::substrait::ReadRel_ExtensionTable&
ReadRel::_Internal::extension_table(const ReadRel* msg) {
  return *msg->read_type_.extension_table_;
}
void ReadRel::clear_base_schema() {
  if (GetArenaForAllocation() == nullptr && base_schema_ != nullptr) {
    delete base_schema_;
  }
  base_schema_ = nullptr;
}
void ReadRel::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
void ReadRel::set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_read_type();
  if (virtual_table) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_VirtualTable>::GetOwningArena(virtual_table);
    if (message_arena != submessage_arena) {
      virtual_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, virtual_table, submessage_arena);
    }
    set_has_virtual_table();
    read_type_.virtual_table_ = virtual_table;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.virtual_table)
}
void ReadRel::set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_read_type();
  if (local_files) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_LocalFiles>::GetOwningArena(local_files);
    if (message_arena != submessage_arena) {
      local_files = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, local_files, submessage_arena);
    }
    set_has_local_files();
    read_type_.local_files_ = local_files;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.local_files)
}
void ReadRel::set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_read_type();
  if (named_table) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_NamedTable>::GetOwningArena(named_table);
    if (message_arena != submessage_arena) {
      named_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, named_table, submessage_arena);
    }
    set_has_named_table();
    read_type_.named_table_ = named_table;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.named_table)
}
void ReadRel::set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_read_type();
  if (extension_table) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_ExtensionTable>::GetOwningArena(extension_table);
    if (message_arena != submessage_arena) {
      extension_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, extension_table, submessage_arena);
    }
    set_has_extension_table();
    read_type_.extension_table_ = extension_table;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.extension_table)
}
ReadRel::ReadRel(::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.ReadRel)
}
ReadRel::ReadRel(const ReadRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_base_schema()) {
    base_schema_ = new ::substrait::NamedStruct(*from.base_schema_);
  } else {
    base_schema_ = nullptr;
  }
  if (from._internal_has_filter()) {
    filter_ = new ::substrait::Expression(*from.filter_);
  } else {
    filter_ = nullptr;
  }
  if (from._internal_has_projection()) {
    projection_ = new ::substrait::Expression_MaskExpression(*from.projection_);
  } else {
    projection_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  clear_has_read_type();
  switch (from.read_type_case()) {
    case kVirtualTable: {
      _internal_mutable_virtual_table()->::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table());
      break;
    }
    case kLocalFiles: {
      _internal_mutable_local_files()->::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files());
      break;
    }
    case kNamedTable: {
      _internal_mutable_named_table()->::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table());
      break;
    }
    case kExtensionTable: {
      _internal_mutable_extension_table()->::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table());
      break;
    }
    case READ_TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel)
}

inline void ReadRel::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&advanced_extension_) -
    reinterpret_cast<char*>(&common_)) + sizeof(advanced_extension_));
clear_has_read_type();
}

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

inline void ReadRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete base_schema_;
  if (this != internal_default_instance()) delete filter_;
  if (this != internal_default_instance()) delete projection_;
  if (this != internal_default_instance()) delete advanced_extension_;
  if (has_read_type()) {
    clear_read_type();
  }
}

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

void ReadRel::clear_read_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel)
  switch (read_type_case()) {
    case kVirtualTable: {
      if (GetArenaForAllocation() == nullptr) {
        delete read_type_.virtual_table_;
      }
      break;
    }
    case kLocalFiles: {
      if (GetArenaForAllocation() == nullptr) {
        delete read_type_.local_files_;
      }
      break;
    }
    case kNamedTable: {
      if (GetArenaForAllocation() == nullptr) {
        delete read_type_.named_table_;
      }
      break;
    }
    case kExtensionTable: {
      if (GetArenaForAllocation() == nullptr) {
        delete read_type_.extension_table_;
      }
      break;
    }
    case READ_TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = READ_TYPE_NOT_SET;
}


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

  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
    delete common_;
  }
  common_ = nullptr;
  if (GetArenaForAllocation() == nullptr && base_schema_ != nullptr) {
    delete base_schema_;
  }
  base_schema_ = nullptr;
  if (GetArenaForAllocation() == nullptr && filter_ != nullptr) {
    delete filter_;
  }
  filter_ = nullptr;
  if (GetArenaForAllocation() == nullptr && projection_ != nullptr) {
    delete projection_;
  }
  projection_ = nullptr;
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
  clear_read_type();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ReadRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.NamedStruct base_schema = 2 [json_name = "baseSchema"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_base_schema(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression filter = 3 [json_name = "filter"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.MaskExpression projection = 4 [json_name = "projection"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_projection(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.ReadRel.VirtualTable virtual_table = 5 [json_name = "virtualTable"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_virtual_table(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.ReadRel.LocalFiles local_files = 6 [json_name = "localFiles"];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_local_files(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.ReadRel.NamedTable named_table = 7 [json_name = "namedTable"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_named_table(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.ReadRel.ExtensionTable extension_table = 8 [json_name = "extensionTable"];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_extension_table(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* ReadRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  // .substrait.Expression.MaskExpression projection = 4 [json_name = "projection"];
  if (this->_internal_has_projection()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::projection(this), target, stream);
  }

  // .substrait.ReadRel.VirtualTable virtual_table = 5 [json_name = "virtualTable"];
  if (_internal_has_virtual_table()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::virtual_table(this), target, stream);
  }

  // .substrait.ReadRel.LocalFiles local_files = 6 [json_name = "localFiles"];
  if (_internal_has_local_files()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::local_files(this), target, stream);
  }

  // .substrait.ReadRel.NamedTable named_table = 7 [json_name = "namedTable"];
  if (_internal_has_named_table()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::named_table(this), target, stream);
  }

  // .substrait.ReadRel.ExtensionTable extension_table = 8 [json_name = "extensionTable"];
  if (_internal_has_extension_table()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::extension_table(this), target, stream);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.ReadRel)
  return target;
}

size_t ReadRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel)
  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.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.NamedStruct base_schema = 2 [json_name = "baseSchema"];
  if (this->_internal_has_base_schema()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *base_schema_);
  }

  // .substrait.Expression filter = 3 [json_name = "filter"];
  if (this->_internal_has_filter()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *filter_);
  }

  // .substrait.Expression.MaskExpression projection = 4 [json_name = "projection"];
  if (this->_internal_has_projection()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *projection_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  switch (read_type_case()) {
    // .substrait.ReadRel.VirtualTable virtual_table = 5 [json_name = "virtualTable"];
    case kVirtualTable: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *read_type_.virtual_table_);
      break;
    }
    // .substrait.ReadRel.LocalFiles local_files = 6 [json_name = "localFiles"];
    case kLocalFiles: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *read_type_.local_files_);
      break;
    }
    // .substrait.ReadRel.NamedTable named_table = 7 [json_name = "namedTable"];
    case kNamedTable: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *read_type_.named_table_);
      break;
    }
    // .substrait.ReadRel.ExtensionTable extension_table = 8 [json_name = "extensionTable"];
    case kExtensionTable: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *read_type_.extension_table_);
      break;
    }
    case READ_TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_base_schema()) {
    _internal_mutable_base_schema()->::substrait::NamedStruct::MergeFrom(from._internal_base_schema());
  }
  if (from._internal_has_filter()) {
    _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter());
  }
  if (from._internal_has_projection()) {
    _internal_mutable_projection()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_projection());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  switch (from.read_type_case()) {
    case kVirtualTable: {
      _internal_mutable_virtual_table()->::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table());
      break;
    }
    case kLocalFiles: {
      _internal_mutable_local_files()->::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files());
      break;
    }
    case kNamedTable: {
      _internal_mutable_named_table()->::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table());
      break;
    }
    case kExtensionTable: {
      _internal_mutable_extension_table()->::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table());
      break;
    }
    case READ_TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void ReadRel::InternalSwap(ReadRel* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ReadRel, advanced_extension_)
      + sizeof(ReadRel::advanced_extension_)
      - PROTOBUF_FIELD_OFFSET(ReadRel, common_)>(
          reinterpret_cast<char*>(&common_),
          reinterpret_cast<char*>(&other->common_));
  swap(read_type_, other->read_type_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata ReadRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[11]);
}

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

class ProjectRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const ProjectRel* msg);
  static const ::substrait::Rel& input(const ProjectRel* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ProjectRel* msg);
};

const ::substrait::RelCommon&
ProjectRel::_Internal::common(const ProjectRel* msg) {
  return *msg->common_;
}
const ::substrait::Rel&
ProjectRel::_Internal::input(const ProjectRel* msg) {
  return *msg->input_;
}
const ::substrait::extensions::AdvancedExtension&
ProjectRel::_Internal::advanced_extension(const ProjectRel* msg) {
  return *msg->advanced_extension_;
}
void ProjectRel::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
ProjectRel::ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  expressions_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.ProjectRel)
}
ProjectRel::ProjectRel(const ProjectRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      expressions_(from.expressions_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_input()) {
    input_ = new ::substrait::Rel(*from.input_);
  } else {
    input_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.ProjectRel)
}

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

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

inline void ProjectRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete input_;
  if (this != internal_default_instance()) delete advanced_extension_;
}

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

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

  expressions_.Clear();
  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
    delete common_;
  }
  common_ = nullptr;
  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
    delete input_;
  }
  input_ = nullptr;
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ProjectRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel input = 2 [json_name = "input"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.Expression expressions = 3 [json_name = "expressions"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_expressions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* ProjectRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ProjectRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // repeated .substrait.Expression expressions = 3 [json_name = "expressions"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_expressions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_expressions(i), target, stream);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.ProjectRel)
  return target;
}

size_t ProjectRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.ProjectRel)
  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.Expression expressions = 3 [json_name = "expressions"];
  total_size += 1UL * this->_internal_expressions_size();
  for (const auto& msg : this->expressions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.Rel input = 2 [json_name = "input"];
  if (this->_internal_has_input()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *input_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  expressions_.MergeFrom(from.expressions_);
  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_input()) {
    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata ProjectRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[12]);
}

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

class JoinRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const JoinRel* msg);
  static const ::substrait::Rel& left(const JoinRel* msg);
  static const ::substrait::Rel& right(const JoinRel* msg);
  static const ::substrait::Expression& expression(const JoinRel* msg);
  static const ::substrait::Expression& post_join_filter(const JoinRel* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const JoinRel* msg);
};

const ::substrait::RelCommon&
JoinRel::_Internal::common(const JoinRel* msg) {
  return *msg->common_;
}
const ::substrait::Rel&
JoinRel::_Internal::left(const JoinRel* msg) {
  return *msg->left_;
}
const ::substrait::Rel&
JoinRel::_Internal::right(const JoinRel* msg) {
  return *msg->right_;
}
const ::substrait::Expression&
JoinRel::_Internal::expression(const JoinRel* msg) {
  return *msg->expression_;
}
const ::substrait::Expression&
JoinRel::_Internal::post_join_filter(const JoinRel* msg) {
  return *msg->post_join_filter_;
}
const ::substrait::extensions::AdvancedExtension&
JoinRel::_Internal::advanced_extension(const JoinRel* msg) {
  return *msg->advanced_extension_;
}
void JoinRel::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
JoinRel::JoinRel(::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.JoinRel)
}
JoinRel::JoinRel(const JoinRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_left()) {
    left_ = new ::substrait::Rel(*from.left_);
  } else {
    left_ = nullptr;
  }
  if (from._internal_has_right()) {
    right_ = new ::substrait::Rel(*from.right_);
  } else {
    right_ = nullptr;
  }
  if (from._internal_has_expression()) {
    expression_ = new ::substrait::Expression(*from.expression_);
  } else {
    expression_ = nullptr;
  }
  if (from._internal_has_post_join_filter()) {
    post_join_filter_ = new ::substrait::Expression(*from.post_join_filter_);
  } else {
    post_join_filter_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:substrait.JoinRel)
}

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

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

inline void JoinRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete left_;
  if (this != internal_default_instance()) delete right_;
  if (this != internal_default_instance()) delete expression_;
  if (this != internal_default_instance()) delete post_join_filter_;
  if (this != internal_default_instance()) delete advanced_extension_;
}

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

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

  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
    delete common_;
  }
  common_ = nullptr;
  if (GetArenaForAllocation() == nullptr && left_ != nullptr) {
    delete left_;
  }
  left_ = nullptr;
  if (GetArenaForAllocation() == nullptr && right_ != nullptr) {
    delete right_;
  }
  right_ = nullptr;
  if (GetArenaForAllocation() == nullptr && expression_ != nullptr) {
    delete expression_;
  }
  expression_ = nullptr;
  if (GetArenaForAllocation() == nullptr && post_join_filter_ != nullptr) {
    delete post_join_filter_;
  }
  post_join_filter_ = nullptr;
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
  type_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* JoinRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel left = 2 [json_name = "left"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_left(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel right = 3 [json_name = "right"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_right(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression expression = 4 [json_name = "expression"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression post_join_filter = 5 [json_name = "postJoinFilter"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_post_join_filter(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.JoinRel.JoinType type = 6 [json_name = "type"];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_type(static_cast<::substrait::JoinRel_JoinType>(val));
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* JoinRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.JoinRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

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

  // .substrait.Expression post_join_filter = 5 [json_name = "postJoinFilter"];
  if (this->_internal_has_post_join_filter()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::post_join_filter(this), target, stream);
  }

  // .substrait.JoinRel.JoinType type = 6 [json_name = "type"];
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      6, this->_internal_type(), target);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.JoinRel)
  return target;
}

size_t JoinRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.JoinRel)
  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.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.Rel left = 2 [json_name = "left"];
  if (this->_internal_has_left()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *left_);
  }

  // .substrait.Rel right = 3 [json_name = "right"];
  if (this->_internal_has_right()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *right_);
  }

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

  // .substrait.Expression post_join_filter = 5 [json_name = "postJoinFilter"];
  if (this->_internal_has_post_join_filter()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *post_join_filter_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  // .substrait.JoinRel.JoinType type = 6 [json_name = "type"];
  if (this->_internal_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_left()) {
    _internal_mutable_left()->::substrait::Rel::MergeFrom(from._internal_left());
  }
  if (from._internal_has_right()) {
    _internal_mutable_right()->::substrait::Rel::MergeFrom(from._internal_right());
  }
  if (from._internal_has_expression()) {
    _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression());
  }
  if (from._internal_has_post_join_filter()) {
    _internal_mutable_post_join_filter()->::substrait::Expression::MergeFrom(from._internal_post_join_filter());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  if (from._internal_type() != 0) {
    _internal_set_type(from._internal_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata JoinRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[13]);
}

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

class CrossRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const CrossRel* msg);
  static const ::substrait::Rel& left(const CrossRel* msg);
  static const ::substrait::Rel& right(const CrossRel* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const CrossRel* msg);
};

const ::substrait::RelCommon&
CrossRel::_Internal::common(const CrossRel* msg) {
  return *msg->common_;
}
const ::substrait::Rel&
CrossRel::_Internal::left(const CrossRel* msg) {
  return *msg->left_;
}
const ::substrait::Rel&
CrossRel::_Internal::right(const CrossRel* msg) {
  return *msg->right_;
}
const ::substrait::extensions::AdvancedExtension&
CrossRel::_Internal::advanced_extension(const CrossRel* msg) {
  return *msg->advanced_extension_;
}
void CrossRel::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
CrossRel::CrossRel(::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.CrossRel)
}
CrossRel::CrossRel(const CrossRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_left()) {
    left_ = new ::substrait::Rel(*from.left_);
  } else {
    left_ = nullptr;
  }
  if (from._internal_has_right()) {
    right_ = new ::substrait::Rel(*from.right_);
  } else {
    right_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.CrossRel)
}

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

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

inline void CrossRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete left_;
  if (this != internal_default_instance()) delete right_;
  if (this != internal_default_instance()) delete advanced_extension_;
}

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

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

  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
    delete common_;
  }
  common_ = nullptr;
  if (GetArenaForAllocation() == nullptr && left_ != nullptr) {
    delete left_;
  }
  left_ = nullptr;
  if (GetArenaForAllocation() == nullptr && right_ != nullptr) {
    delete right_;
  }
  right_ = nullptr;
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CrossRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel left = 2 [json_name = "left"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_left(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel right = 3 [json_name = "right"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_right(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* CrossRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.CrossRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.CrossRel)
  return target;
}

size_t CrossRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.CrossRel)
  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.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.Rel left = 2 [json_name = "left"];
  if (this->_internal_has_left()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *left_);
  }

  // .substrait.Rel right = 3 [json_name = "right"];
  if (this->_internal_has_right()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *right_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_left()) {
    _internal_mutable_left()->::substrait::Rel::MergeFrom(from._internal_left());
  }
  if (from._internal_has_right()) {
    _internal_mutable_right()->::substrait::Rel::MergeFrom(from._internal_right());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata CrossRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[14]);
}

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

class FetchRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const FetchRel* msg);
  static const ::substrait::Rel& input(const FetchRel* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const FetchRel* msg);
};

const ::substrait::RelCommon&
FetchRel::_Internal::common(const FetchRel* msg) {
  return *msg->common_;
}
const ::substrait::Rel&
FetchRel::_Internal::input(const FetchRel* msg) {
  return *msg->input_;
}
const ::substrait::extensions::AdvancedExtension&
FetchRel::_Internal::advanced_extension(const FetchRel* msg) {
  return *msg->advanced_extension_;
}
void FetchRel::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
FetchRel::FetchRel(::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.FetchRel)
}
FetchRel::FetchRel(const FetchRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_input()) {
    input_ = new ::substrait::Rel(*from.input_);
  } else {
    input_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  ::memcpy(&offset_, &from.offset_,
    static_cast<size_t>(reinterpret_cast<char*>(&count_) -
    reinterpret_cast<char*>(&offset_)) + sizeof(count_));
  // @@protoc_insertion_point(copy_constructor:substrait.FetchRel)
}

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

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

inline void FetchRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete input_;
  if (this != internal_default_instance()) delete advanced_extension_;
}

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

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

  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
    delete common_;
  }
  common_ = nullptr;
  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
    delete input_;
  }
  input_ = nullptr;
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
  ::memset(&offset_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&count_) -
      reinterpret_cast<char*>(&offset_)) + sizeof(count_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FetchRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel input = 2 [json_name = "input"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 offset = 3 [json_name = "offset"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 count = 4 [json_name = "count"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* FetchRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FetchRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // int64 offset = 3 [json_name = "offset"];
  if (this->_internal_offset() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_offset(), target);
  }

  // int64 count = 4 [json_name = "count"];
  if (this->_internal_count() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_count(), target);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.FetchRel)
  return target;
}

size_t FetchRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FetchRel)
  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.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.Rel input = 2 [json_name = "input"];
  if (this->_internal_has_input()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *input_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  // int64 offset = 3 [json_name = "offset"];
  if (this->_internal_offset() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
  }

  // int64 count = 4 [json_name = "count"];
  if (this->_internal_count() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_count());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_input()) {
    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  if (from._internal_offset() != 0) {
    _internal_set_offset(from._internal_offset());
  }
  if (from._internal_count() != 0) {
    _internal_set_count(from._internal_count());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata FetchRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[15]);
}

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

class AggregateRel_Grouping::_Internal {
 public:
};

AggregateRel_Grouping::AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  grouping_expressions_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel.Grouping)
}
AggregateRel_Grouping::AggregateRel_Grouping(const AggregateRel_Grouping& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      grouping_expressions_(from.grouping_expressions_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Grouping)
}

inline void AggregateRel_Grouping::SharedCtor() {
}

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

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

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

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

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

const char* AggregateRel_Grouping::_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.Expression grouping_expressions = 1 [json_name = "groupingExpressions"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_grouping_expressions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* AggregateRel_Grouping::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Grouping)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression grouping_expressions = 1 [json_name = "groupingExpressions"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_grouping_expressions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_grouping_expressions(i), 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.AggregateRel.Grouping)
  return target;
}

size_t AggregateRel_Grouping::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Grouping)
  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.Expression grouping_expressions = 1 [json_name = "groupingExpressions"];
  total_size += 1UL * this->_internal_grouping_expressions_size();
  for (const auto& msg : this->grouping_expressions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  grouping_expressions_.MergeFrom(from.grouping_expressions_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void AggregateRel_Grouping::InternalSwap(AggregateRel_Grouping* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  grouping_expressions_.InternalSwap(&other->grouping_expressions_);
}

::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Grouping::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[16]);
}

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

class AggregateRel_Measure::_Internal {
 public:
  static const ::substrait::AggregateFunction& measure(const AggregateRel_Measure* msg);
  static const ::substrait::Expression& filter(const AggregateRel_Measure* msg);
};

const ::substrait::AggregateFunction&
AggregateRel_Measure::_Internal::measure(const AggregateRel_Measure* msg) {
  return *msg->measure_;
}
const ::substrait::Expression&
AggregateRel_Measure::_Internal::filter(const AggregateRel_Measure* msg) {
  return *msg->filter_;
}
AggregateRel_Measure::AggregateRel_Measure(::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.AggregateRel.Measure)
}
AggregateRel_Measure::AggregateRel_Measure(const AggregateRel_Measure& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_measure()) {
    measure_ = new ::substrait::AggregateFunction(*from.measure_);
  } else {
    measure_ = nullptr;
  }
  if (from._internal_has_filter()) {
    filter_ = new ::substrait::Expression(*from.filter_);
  } else {
    filter_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Measure)
}

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

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

inline void AggregateRel_Measure::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete measure_;
  if (this != internal_default_instance()) delete filter_;
}

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

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

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

const char* AggregateRel_Measure::_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.AggregateFunction measure = 1 [json_name = "measure"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_measure(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression filter = 2 [json_name = "filter"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), 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* AggregateRel_Measure::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Measure)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // .substrait.Expression filter = 2 [json_name = "filter"];
  if (this->_internal_has_filter()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::filter(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.AggregateRel.Measure)
  return target;
}

size_t AggregateRel_Measure::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Measure)
  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.AggregateFunction measure = 1 [json_name = "measure"];
  if (this->_internal_has_measure()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *measure_);
  }

  // .substrait.Expression filter = 2 [json_name = "filter"];
  if (this->_internal_has_filter()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *filter_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_measure()) {
    _internal_mutable_measure()->::substrait::AggregateFunction::MergeFrom(from._internal_measure());
  }
  if (from._internal_has_filter()) {
    _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Measure::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[17]);
}

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

class AggregateRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const AggregateRel* msg);
  static const ::substrait::Rel& input(const AggregateRel* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const AggregateRel* msg);
};

const ::substrait::RelCommon&
AggregateRel::_Internal::common(const AggregateRel* msg) {
  return *msg->common_;
}
const ::substrait::Rel&
AggregateRel::_Internal::input(const AggregateRel* msg) {
  return *msg->input_;
}
const ::substrait::extensions::AdvancedExtension&
AggregateRel::_Internal::advanced_extension(const AggregateRel* msg) {
  return *msg->advanced_extension_;
}
void AggregateRel::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
AggregateRel::AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  groupings_(arena),
  measures_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel)
}
AggregateRel::AggregateRel(const AggregateRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      groupings_(from.groupings_),
      measures_(from.measures_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_input()) {
    input_ = new ::substrait::Rel(*from.input_);
  } else {
    input_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel)
}

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

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

inline void AggregateRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete input_;
  if (this != internal_default_instance()) delete advanced_extension_;
}

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

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

  groupings_.Clear();
  measures_.Clear();
  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
    delete common_;
  }
  common_ = nullptr;
  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
    delete input_;
  }
  input_ = nullptr;
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* AggregateRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel input = 2 [json_name = "input"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.AggregateRel.Grouping groupings = 3 [json_name = "groupings"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_groupings(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.AggregateRel.Measure measures = 4 [json_name = "measures"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_measures(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* AggregateRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // repeated .substrait.AggregateRel.Grouping groupings = 3 [json_name = "groupings"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_groupings_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_groupings(i), target, stream);
  }

  // repeated .substrait.AggregateRel.Measure measures = 4 [json_name = "measures"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_measures_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_measures(i), target, stream);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.AggregateRel)
  return target;
}

size_t AggregateRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel)
  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.AggregateRel.Grouping groupings = 3 [json_name = "groupings"];
  total_size += 1UL * this->_internal_groupings_size();
  for (const auto& msg : this->groupings_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .substrait.AggregateRel.Measure measures = 4 [json_name = "measures"];
  total_size += 1UL * this->_internal_measures_size();
  for (const auto& msg : this->measures_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.Rel input = 2 [json_name = "input"];
  if (this->_internal_has_input()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *input_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  groupings_.MergeFrom(from.groupings_);
  measures_.MergeFrom(from.measures_);
  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_input()) {
    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void AggregateRel::InternalSwap(AggregateRel* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  groupings_.InternalSwap(&other->groupings_);
  measures_.InternalSwap(&other->measures_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(AggregateRel, advanced_extension_)
      + sizeof(AggregateRel::advanced_extension_)
      - PROTOBUF_FIELD_OFFSET(AggregateRel, common_)>(
          reinterpret_cast<char*>(&common_),
          reinterpret_cast<char*>(&other->common_));
}

::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[18]);
}

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

class SortRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const SortRel* msg);
  static const ::substrait::Rel& input(const SortRel* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const SortRel* msg);
};

const ::substrait::RelCommon&
SortRel::_Internal::common(const SortRel* msg) {
  return *msg->common_;
}
const ::substrait::Rel&
SortRel::_Internal::input(const SortRel* msg) {
  return *msg->input_;
}
const ::substrait::extensions::AdvancedExtension&
SortRel::_Internal::advanced_extension(const SortRel* msg) {
  return *msg->advanced_extension_;
}
void SortRel::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
SortRel::SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  sorts_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.SortRel)
}
SortRel::SortRel(const SortRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      sorts_(from.sorts_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_input()) {
    input_ = new ::substrait::Rel(*from.input_);
  } else {
    input_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.SortRel)
}

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

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

inline void SortRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete input_;
  if (this != internal_default_instance()) delete advanced_extension_;
}

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

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

  sorts_.Clear();
  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
    delete common_;
  }
  common_ = nullptr;
  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
    delete input_;
  }
  input_ = nullptr;
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* SortRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel input = 2 [json_name = "input"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.SortField sorts = 3 [json_name = "sorts"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_sorts(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* SortRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.SortRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // repeated .substrait.SortField sorts = 3 [json_name = "sorts"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_sorts_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_sorts(i), target, stream);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.SortRel)
  return target;
}

size_t SortRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.SortRel)
  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.SortField sorts = 3 [json_name = "sorts"];
  total_size += 1UL * this->_internal_sorts_size();
  for (const auto& msg : this->sorts_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.Rel input = 2 [json_name = "input"];
  if (this->_internal_has_input()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *input_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  sorts_.MergeFrom(from.sorts_);
  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_input()) {
    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata SortRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[19]);
}

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

class FilterRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const FilterRel* msg);
  static const ::substrait::Rel& input(const FilterRel* msg);
  static const ::substrait::Expression& condition(const FilterRel* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const FilterRel* msg);
};

const ::substrait::RelCommon&
FilterRel::_Internal::common(const FilterRel* msg) {
  return *msg->common_;
}
const ::substrait::Rel&
FilterRel::_Internal::input(const FilterRel* msg) {
  return *msg->input_;
}
const ::substrait::Expression&
FilterRel::_Internal::condition(const FilterRel* msg) {
  return *msg->condition_;
}
const ::substrait::extensions::AdvancedExtension&
FilterRel::_Internal::advanced_extension(const FilterRel* msg) {
  return *msg->advanced_extension_;
}
void FilterRel::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
FilterRel::FilterRel(::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.FilterRel)
}
FilterRel::FilterRel(const FilterRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_input()) {
    input_ = new ::substrait::Rel(*from.input_);
  } else {
    input_ = nullptr;
  }
  if (from._internal_has_condition()) {
    condition_ = new ::substrait::Expression(*from.condition_);
  } else {
    condition_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.FilterRel)
}

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

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

inline void FilterRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete input_;
  if (this != internal_default_instance()) delete condition_;
  if (this != internal_default_instance()) delete advanced_extension_;
}

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

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

  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
    delete common_;
  }
  common_ = nullptr;
  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
    delete input_;
  }
  input_ = nullptr;
  if (GetArenaForAllocation() == nullptr && condition_ != nullptr) {
    delete condition_;
  }
  condition_ = nullptr;
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FilterRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel input = 2 [json_name = "input"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression condition = 3 [json_name = "condition"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_condition(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* FilterRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FilterRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.FilterRel)
  return target;
}

size_t FilterRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FilterRel)
  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.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.Rel input = 2 [json_name = "input"];
  if (this->_internal_has_input()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *input_);
  }

  // .substrait.Expression condition = 3 [json_name = "condition"];
  if (this->_internal_has_condition()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *condition_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_input()) {
    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
  }
  if (from._internal_has_condition()) {
    _internal_mutable_condition()->::substrait::Expression::MergeFrom(from._internal_condition());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata FilterRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[20]);
}

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

class SetRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const SetRel* msg);
  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const SetRel* msg);
};

const ::substrait::RelCommon&
SetRel::_Internal::common(const SetRel* msg) {
  return *msg->common_;
}
const ::substrait::extensions::AdvancedExtension&
SetRel::_Internal::advanced_extension(const SetRel* msg) {
  return *msg->advanced_extension_;
}
void SetRel::clear_advanced_extension() {
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
}
SetRel::SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  inputs_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.SetRel)
}
SetRel::SetRel(const SetRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      inputs_(from.inputs_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_advanced_extension()) {
    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
  } else {
    advanced_extension_ = nullptr;
  }
  op_ = from.op_;
  // @@protoc_insertion_point(copy_constructor:substrait.SetRel)
}

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

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

inline void SetRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete advanced_extension_;
}

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

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

  inputs_.Clear();
  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
    delete common_;
  }
  common_ = nullptr;
  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
    delete advanced_extension_;
  }
  advanced_extension_ = nullptr;
  op_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* SetRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.Rel inputs = 2 [json_name = "inputs"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_inputs(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.SetRel.SetOp op = 3 [json_name = "op"];
      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_op(static_cast<::substrait::SetRel_SetOp>(val));
        } else
          goto handle_unusual;
        continue;
      // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), 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* SetRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.SetRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // repeated .substrait.Rel inputs = 2 [json_name = "inputs"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_inputs_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_inputs(i), target, stream);
  }

  // .substrait.SetRel.SetOp op = 3 [json_name = "op"];
  if (this->_internal_op() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_op(), target);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::advanced_extension(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.SetRel)
  return target;
}

size_t SetRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.SetRel)
  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.Rel inputs = 2 [json_name = "inputs"];
  total_size += 1UL * this->_internal_inputs_size();
  for (const auto& msg : this->inputs_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.extensions.AdvancedExtension advanced_extension = 10 [json_name = "advancedExtension"];
  if (this->_internal_has_advanced_extension()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *advanced_extension_);
  }

  // .substrait.SetRel.SetOp op = 3 [json_name = "op"];
  if (this->_internal_op() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  inputs_.MergeFrom(from.inputs_);
  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_advanced_extension()) {
    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
  }
  if (from._internal_op() != 0) {
    _internal_set_op(from._internal_op());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata SetRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[21]);
}

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

class ExtensionSingleRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const ExtensionSingleRel* msg);
  static const ::substrait::Rel& input(const ExtensionSingleRel* msg);
  static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionSingleRel* msg);
};

const ::substrait::RelCommon&
ExtensionSingleRel::_Internal::common(const ExtensionSingleRel* msg) {
  return *msg->common_;
}
const ::substrait::Rel&
ExtensionSingleRel::_Internal::input(const ExtensionSingleRel* msg) {
  return *msg->input_;
}
const ::PROTOBUF_NAMESPACE_ID::Any&
ExtensionSingleRel::_Internal::detail(const ExtensionSingleRel* msg) {
  return *msg->detail_;
}
void ExtensionSingleRel::clear_detail() {
  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
    delete detail_;
  }
  detail_ = nullptr;
}
ExtensionSingleRel::ExtensionSingleRel(::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.ExtensionSingleRel)
}
ExtensionSingleRel::ExtensionSingleRel(const ExtensionSingleRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_input()) {
    input_ = new ::substrait::Rel(*from.input_);
  } else {
    input_ = nullptr;
  }
  if (from._internal_has_detail()) {
    detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_);
  } else {
    detail_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.ExtensionSingleRel)
}

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

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

inline void ExtensionSingleRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete input_;
  if (this != internal_default_instance()) delete detail_;
}

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

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

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

const char* ExtensionSingleRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel input = 2 [json_name = "input"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .google.protobuf.Any detail = 3 [json_name = "detail"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_detail(), 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* ExtensionSingleRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionSingleRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // .google.protobuf.Any detail = 3 [json_name = "detail"];
  if (this->_internal_has_detail()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::detail(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.ExtensionSingleRel)
  return target;
}

size_t ExtensionSingleRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionSingleRel)
  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.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .substrait.Rel input = 2 [json_name = "input"];
  if (this->_internal_has_input()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *input_);
  }

  // .google.protobuf.Any detail = 3 [json_name = "detail"];
  if (this->_internal_has_detail()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *detail_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_input()) {
    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
  }
  if (from._internal_has_detail()) {
    _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata ExtensionSingleRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[22]);
}

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

class ExtensionLeafRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const ExtensionLeafRel* msg);
  static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionLeafRel* msg);
};

const ::substrait::RelCommon&
ExtensionLeafRel::_Internal::common(const ExtensionLeafRel* msg) {
  return *msg->common_;
}
const ::PROTOBUF_NAMESPACE_ID::Any&
ExtensionLeafRel::_Internal::detail(const ExtensionLeafRel* msg) {
  return *msg->detail_;
}
void ExtensionLeafRel::clear_detail() {
  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
    delete detail_;
  }
  detail_ = nullptr;
}
ExtensionLeafRel::ExtensionLeafRel(::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.ExtensionLeafRel)
}
ExtensionLeafRel::ExtensionLeafRel(const ExtensionLeafRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_detail()) {
    detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_);
  } else {
    detail_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.ExtensionLeafRel)
}

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

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

inline void ExtensionLeafRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete detail_;
}

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

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

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

const char* ExtensionLeafRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .google.protobuf.Any detail = 2 [json_name = "detail"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_detail(), 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* ExtensionLeafRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionLeafRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // .google.protobuf.Any detail = 2 [json_name = "detail"];
  if (this->_internal_has_detail()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::detail(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.ExtensionLeafRel)
  return target;
}

size_t ExtensionLeafRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionLeafRel)
  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.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .google.protobuf.Any detail = 2 [json_name = "detail"];
  if (this->_internal_has_detail()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *detail_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_detail()) {
    _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata ExtensionLeafRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[23]);
}

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

class ExtensionMultiRel::_Internal {
 public:
  static const ::substrait::RelCommon& common(const ExtensionMultiRel* msg);
  static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionMultiRel* msg);
};

const ::substrait::RelCommon&
ExtensionMultiRel::_Internal::common(const ExtensionMultiRel* msg) {
  return *msg->common_;
}
const ::PROTOBUF_NAMESPACE_ID::Any&
ExtensionMultiRel::_Internal::detail(const ExtensionMultiRel* msg) {
  return *msg->detail_;
}
void ExtensionMultiRel::clear_detail() {
  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
    delete detail_;
  }
  detail_ = nullptr;
}
ExtensionMultiRel::ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  inputs_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.ExtensionMultiRel)
}
ExtensionMultiRel::ExtensionMultiRel(const ExtensionMultiRel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      inputs_(from.inputs_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_common()) {
    common_ = new ::substrait::RelCommon(*from.common_);
  } else {
    common_ = nullptr;
  }
  if (from._internal_has_detail()) {
    detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_);
  } else {
    detail_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.ExtensionMultiRel)
}

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

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

inline void ExtensionMultiRel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete common_;
  if (this != internal_default_instance()) delete detail_;
}

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

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

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

const char* ExtensionMultiRel::_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.RelCommon common = 1 [json_name = "common"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.Rel inputs = 2 [json_name = "inputs"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_inputs(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .google.protobuf.Any detail = 3 [json_name = "detail"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_detail(), 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* ExtensionMultiRel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionMultiRel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // repeated .substrait.Rel inputs = 2 [json_name = "inputs"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_inputs_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_inputs(i), target, stream);
  }

  // .google.protobuf.Any detail = 3 [json_name = "detail"];
  if (this->_internal_has_detail()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::detail(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.ExtensionMultiRel)
  return target;
}

size_t ExtensionMultiRel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionMultiRel)
  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.Rel inputs = 2 [json_name = "inputs"];
  total_size += 1UL * this->_internal_inputs_size();
  for (const auto& msg : this->inputs_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.RelCommon common = 1 [json_name = "common"];
  if (this->_internal_has_common()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *common_);
  }

  // .google.protobuf.Any detail = 3 [json_name = "detail"];
  if (this->_internal_has_detail()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *detail_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  inputs_.MergeFrom(from.inputs_);
  if (from._internal_has_common()) {
    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
  }
  if (from._internal_has_detail()) {
    _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata ExtensionMultiRel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[24]);
}

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

class RelRoot::_Internal {
 public:
  static const ::substrait::Rel& input(const RelRoot* msg);
};

const ::substrait::Rel&
RelRoot::_Internal::input(const RelRoot* msg) {
  return *msg->input_;
}
RelRoot::RelRoot(::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.RelRoot)
}
RelRoot::RelRoot(const RelRoot& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      names_(from.names_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_input()) {
    input_ = new ::substrait::Rel(*from.input_);
  } else {
    input_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.RelRoot)
}

inline void RelRoot::SharedCtor() {
input_ = nullptr;
}

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

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

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

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

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

const char* RelRoot::_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.Rel input = 1 [json_name = "input"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated string names = 2 [json_name = "names"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          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.RelRoot.names"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* RelRoot::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelRoot)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // repeated string names = 2 [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.RelRoot.names");
    target = stream->WriteString(2, s, 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.RelRoot)
  return target;
}

size_t RelRoot::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.RelRoot)
  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 = 2 [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.Rel input = 1 [json_name = "input"];
  if (this->_internal_has_input()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *input_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  names_.MergeFrom(from.names_);
  if (from._internal_has_input()) {
    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata RelRoot::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[25]);
}

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

class Rel::_Internal {
 public:
  static const ::substrait::ReadRel& read(const Rel* msg);
  static const ::substrait::FilterRel& filter(const Rel* msg);
  static const ::substrait::FetchRel& fetch(const Rel* msg);
  static const ::substrait::AggregateRel& aggregate(const Rel* msg);
  static const ::substrait::SortRel& sort(const Rel* msg);
  static const ::substrait::JoinRel& join(const Rel* msg);
  static const ::substrait::ProjectRel& project(const Rel* msg);
  static const ::substrait::SetRel& set(const Rel* msg);
  static const ::substrait::ExtensionSingleRel& extension_single(const Rel* msg);
  static const ::substrait::ExtensionMultiRel& extension_multi(const Rel* msg);
  static const ::substrait::ExtensionLeafRel& extension_leaf(const Rel* msg);
  static const ::substrait::CrossRel& cross(const Rel* msg);
};

const ::substrait::ReadRel&
Rel::_Internal::read(const Rel* msg) {
  return *msg->rel_type_.read_;
}
const ::substrait::FilterRel&
Rel::_Internal::filter(const Rel* msg) {
  return *msg->rel_type_.filter_;
}
const ::substrait::FetchRel&
Rel::_Internal::fetch(const Rel* msg) {
  return *msg->rel_type_.fetch_;
}
const ::substrait::AggregateRel&
Rel::_Internal::aggregate(const Rel* msg) {
  return *msg->rel_type_.aggregate_;
}
const ::substrait::SortRel&
Rel::_Internal::sort(const Rel* msg) {
  return *msg->rel_type_.sort_;
}
const ::substrait::JoinRel&
Rel::_Internal::join(const Rel* msg) {
  return *msg->rel_type_.join_;
}
const ::substrait::ProjectRel&
Rel::_Internal::project(const Rel* msg) {
  return *msg->rel_type_.project_;
}
const ::substrait::SetRel&
Rel::_Internal::set(const Rel* msg) {
  return *msg->rel_type_.set_;
}
const ::substrait::ExtensionSingleRel&
Rel::_Internal::extension_single(const Rel* msg) {
  return *msg->rel_type_.extension_single_;
}
const ::substrait::ExtensionMultiRel&
Rel::_Internal::extension_multi(const Rel* msg) {
  return *msg->rel_type_.extension_multi_;
}
const ::substrait::ExtensionLeafRel&
Rel::_Internal::extension_leaf(const Rel* msg) {
  return *msg->rel_type_.extension_leaf_;
}
const ::substrait::CrossRel&
Rel::_Internal::cross(const Rel* msg) {
  return *msg->rel_type_.cross_;
}
void Rel::set_allocated_read(::substrait::ReadRel* read) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (read) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel>::GetOwningArena(read);
    if (message_arena != submessage_arena) {
      read = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, read, submessage_arena);
    }
    set_has_read();
    rel_type_.read_ = read;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.read)
}
void Rel::set_allocated_filter(::substrait::FilterRel* filter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (filter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FilterRel>::GetOwningArena(filter);
    if (message_arena != submessage_arena) {
      filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, filter, submessage_arena);
    }
    set_has_filter();
    rel_type_.filter_ = filter;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.filter)
}
void Rel::set_allocated_fetch(::substrait::FetchRel* fetch) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (fetch) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FetchRel>::GetOwningArena(fetch);
    if (message_arena != submessage_arena) {
      fetch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fetch, submessage_arena);
    }
    set_has_fetch();
    rel_type_.fetch_ = fetch;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.fetch)
}
void Rel::set_allocated_aggregate(::substrait::AggregateRel* aggregate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (aggregate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::AggregateRel>::GetOwningArena(aggregate);
    if (message_arena != submessage_arena) {
      aggregate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, aggregate, submessage_arena);
    }
    set_has_aggregate();
    rel_type_.aggregate_ = aggregate;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.aggregate)
}
void Rel::set_allocated_sort(::substrait::SortRel* sort) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (sort) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::SortRel>::GetOwningArena(sort);
    if (message_arena != submessage_arena) {
      sort = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sort, submessage_arena);
    }
    set_has_sort();
    rel_type_.sort_ = sort;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.sort)
}
void Rel::set_allocated_join(::substrait::JoinRel* join) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (join) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::JoinRel>::GetOwningArena(join);
    if (message_arena != submessage_arena) {
      join = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, join, submessage_arena);
    }
    set_has_join();
    rel_type_.join_ = join;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.join)
}
void Rel::set_allocated_project(::substrait::ProjectRel* project) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (project) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ProjectRel>::GetOwningArena(project);
    if (message_arena != submessage_arena) {
      project = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, project, submessage_arena);
    }
    set_has_project();
    rel_type_.project_ = project;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.project)
}
void Rel::set_allocated_set(::substrait::SetRel* set) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (set) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::SetRel>::GetOwningArena(set);
    if (message_arena != submessage_arena) {
      set = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set, submessage_arena);
    }
    set_has_set();
    rel_type_.set_ = set;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.set)
}
void Rel::set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (extension_single) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionSingleRel>::GetOwningArena(extension_single);
    if (message_arena != submessage_arena) {
      extension_single = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, extension_single, submessage_arena);
    }
    set_has_extension_single();
    rel_type_.extension_single_ = extension_single;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_single)
}
void Rel::set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (extension_multi) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionMultiRel>::GetOwningArena(extension_multi);
    if (message_arena != submessage_arena) {
      extension_multi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, extension_multi, submessage_arena);
    }
    set_has_extension_multi();
    rel_type_.extension_multi_ = extension_multi;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_multi)
}
void Rel::set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (extension_leaf) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionLeafRel>::GetOwningArena(extension_leaf);
    if (message_arena != submessage_arena) {
      extension_leaf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, extension_leaf, submessage_arena);
    }
    set_has_extension_leaf();
    rel_type_.extension_leaf_ = extension_leaf;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_leaf)
}
void Rel::set_allocated_cross(::substrait::CrossRel* cross) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rel_type();
  if (cross) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::CrossRel>::GetOwningArena(cross);
    if (message_arena != submessage_arena) {
      cross = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cross, submessage_arena);
    }
    set_has_cross();
    rel_type_.cross_ = cross;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.cross)
}
Rel::Rel(::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.Rel)
}
Rel::Rel(const Rel& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_rel_type();
  switch (from.rel_type_case()) {
    case kRead: {
      _internal_mutable_read()->::substrait::ReadRel::MergeFrom(from._internal_read());
      break;
    }
    case kFilter: {
      _internal_mutable_filter()->::substrait::FilterRel::MergeFrom(from._internal_filter());
      break;
    }
    case kFetch: {
      _internal_mutable_fetch()->::substrait::FetchRel::MergeFrom(from._internal_fetch());
      break;
    }
    case kAggregate: {
      _internal_mutable_aggregate()->::substrait::AggregateRel::MergeFrom(from._internal_aggregate());
      break;
    }
    case kSort: {
      _internal_mutable_sort()->::substrait::SortRel::MergeFrom(from._internal_sort());
      break;
    }
    case kJoin: {
      _internal_mutable_join()->::substrait::JoinRel::MergeFrom(from._internal_join());
      break;
    }
    case kProject: {
      _internal_mutable_project()->::substrait::ProjectRel::MergeFrom(from._internal_project());
      break;
    }
    case kSet: {
      _internal_mutable_set()->::substrait::SetRel::MergeFrom(from._internal_set());
      break;
    }
    case kExtensionSingle: {
      _internal_mutable_extension_single()->::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single());
      break;
    }
    case kExtensionMulti: {
      _internal_mutable_extension_multi()->::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi());
      break;
    }
    case kExtensionLeaf: {
      _internal_mutable_extension_leaf()->::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf());
      break;
    }
    case kCross: {
      _internal_mutable_cross()->::substrait::CrossRel::MergeFrom(from._internal_cross());
      break;
    }
    case REL_TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Rel)
}

inline void Rel::SharedCtor() {
clear_has_rel_type();
}

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

inline void Rel::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_rel_type()) {
    clear_rel_type();
  }
}

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

void Rel::clear_rel_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Rel)
  switch (rel_type_case()) {
    case kRead: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.read_;
      }
      break;
    }
    case kFilter: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.filter_;
      }
      break;
    }
    case kFetch: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.fetch_;
      }
      break;
    }
    case kAggregate: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.aggregate_;
      }
      break;
    }
    case kSort: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.sort_;
      }
      break;
    }
    case kJoin: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.join_;
      }
      break;
    }
    case kProject: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.project_;
      }
      break;
    }
    case kSet: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.set_;
      }
      break;
    }
    case kExtensionSingle: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.extension_single_;
      }
      break;
    }
    case kExtensionMulti: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.extension_multi_;
      }
      break;
    }
    case kExtensionLeaf: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.extension_leaf_;
      }
      break;
    }
    case kCross: {
      if (GetArenaForAllocation() == nullptr) {
        delete rel_type_.cross_;
      }
      break;
    }
    case REL_TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REL_TYPE_NOT_SET;
}


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

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

const char* Rel::_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.ReadRel read = 1 [json_name = "read"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_read(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FilterRel filter = 2 [json_name = "filter"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FetchRel fetch = 3 [json_name = "fetch"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_fetch(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.AggregateRel aggregate = 4 [json_name = "aggregate"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_aggregate(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.SortRel sort = 5 [json_name = "sort"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_sort(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.JoinRel join = 6 [json_name = "join"];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_join(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.ProjectRel project = 7 [json_name = "project"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_project(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.SetRel set = 8 [json_name = "set"];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_set(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.ExtensionSingleRel extension_single = 9 [json_name = "extensionSingle"];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_extension_single(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.ExtensionMultiRel extension_multi = 10 [json_name = "extensionMulti"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_extension_multi(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.ExtensionLeafRel extension_leaf = 11 [json_name = "extensionLeaf"];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_extension_leaf(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.CrossRel cross = 12 [json_name = "cross"];
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_cross(), 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* Rel::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Rel)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  // .substrait.AggregateRel aggregate = 4 [json_name = "aggregate"];
  if (_internal_has_aggregate()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::aggregate(this), target, stream);
  }

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

  // .substrait.JoinRel join = 6 [json_name = "join"];
  if (_internal_has_join()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::join(this), target, stream);
  }

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

  // .substrait.SetRel set = 8 [json_name = "set"];
  if (_internal_has_set()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::set(this), target, stream);
  }

  // .substrait.ExtensionSingleRel extension_single = 9 [json_name = "extensionSingle"];
  if (_internal_has_extension_single()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        9, _Internal::extension_single(this), target, stream);
  }

  // .substrait.ExtensionMultiRel extension_multi = 10 [json_name = "extensionMulti"];
  if (_internal_has_extension_multi()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::extension_multi(this), target, stream);
  }

  // .substrait.ExtensionLeafRel extension_leaf = 11 [json_name = "extensionLeaf"];
  if (_internal_has_extension_leaf()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::extension_leaf(this), target, stream);
  }

  // .substrait.CrossRel cross = 12 [json_name = "cross"];
  if (_internal_has_cross()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        12, _Internal::cross(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.Rel)
  return target;
}

size_t Rel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Rel)
  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 (rel_type_case()) {
    // .substrait.ReadRel read = 1 [json_name = "read"];
    case kRead: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.read_);
      break;
    }
    // .substrait.FilterRel filter = 2 [json_name = "filter"];
    case kFilter: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.filter_);
      break;
    }
    // .substrait.FetchRel fetch = 3 [json_name = "fetch"];
    case kFetch: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.fetch_);
      break;
    }
    // .substrait.AggregateRel aggregate = 4 [json_name = "aggregate"];
    case kAggregate: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.aggregate_);
      break;
    }
    // .substrait.SortRel sort = 5 [json_name = "sort"];
    case kSort: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.sort_);
      break;
    }
    // .substrait.JoinRel join = 6 [json_name = "join"];
    case kJoin: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.join_);
      break;
    }
    // .substrait.ProjectRel project = 7 [json_name = "project"];
    case kProject: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.project_);
      break;
    }
    // .substrait.SetRel set = 8 [json_name = "set"];
    case kSet: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.set_);
      break;
    }
    // .substrait.ExtensionSingleRel extension_single = 9 [json_name = "extensionSingle"];
    case kExtensionSingle: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.extension_single_);
      break;
    }
    // .substrait.ExtensionMultiRel extension_multi = 10 [json_name = "extensionMulti"];
    case kExtensionMulti: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.extension_multi_);
      break;
    }
    // .substrait.ExtensionLeafRel extension_leaf = 11 [json_name = "extensionLeaf"];
    case kExtensionLeaf: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.extension_leaf_);
      break;
    }
    // .substrait.CrossRel cross = 12 [json_name = "cross"];
    case kCross: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rel_type_.cross_);
      break;
    }
    case REL_TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  switch (from.rel_type_case()) {
    case kRead: {
      _internal_mutable_read()->::substrait::ReadRel::MergeFrom(from._internal_read());
      break;
    }
    case kFilter: {
      _internal_mutable_filter()->::substrait::FilterRel::MergeFrom(from._internal_filter());
      break;
    }
    case kFetch: {
      _internal_mutable_fetch()->::substrait::FetchRel::MergeFrom(from._internal_fetch());
      break;
    }
    case kAggregate: {
      _internal_mutable_aggregate()->::substrait::AggregateRel::MergeFrom(from._internal_aggregate());
      break;
    }
    case kSort: {
      _internal_mutable_sort()->::substrait::SortRel::MergeFrom(from._internal_sort());
      break;
    }
    case kJoin: {
      _internal_mutable_join()->::substrait::JoinRel::MergeFrom(from._internal_join());
      break;
    }
    case kProject: {
      _internal_mutable_project()->::substrait::ProjectRel::MergeFrom(from._internal_project());
      break;
    }
    case kSet: {
      _internal_mutable_set()->::substrait::SetRel::MergeFrom(from._internal_set());
      break;
    }
    case kExtensionSingle: {
      _internal_mutable_extension_single()->::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single());
      break;
    }
    case kExtensionMulti: {
      _internal_mutable_extension_multi()->::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi());
      break;
    }
    case kExtensionLeaf: {
      _internal_mutable_extension_leaf()->::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf());
      break;
    }
    case kCross: {
      _internal_mutable_cross()->::substrait::CrossRel::MergeFrom(from._internal_cross());
      break;
    }
    case REL_TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Rel::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[26]);
}

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

class Expression_Enum_Empty::_Internal {
 public:
};

Expression_Enum_Empty::Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Enum.Empty)
}
Expression_Enum_Empty::Expression_Enum_Empty(const Expression_Enum_Empty& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum.Empty)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Enum_Empty::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Enum_Empty::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum_Empty::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[27]);
}

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

class Expression_Enum::_Internal {
 public:
  static const ::substrait::Expression_Enum_Empty& unspecified(const Expression_Enum* msg);
};

const ::substrait::Expression_Enum_Empty&
Expression_Enum::_Internal::unspecified(const Expression_Enum* msg) {
  return *msg->enum_kind_.unspecified_;
}
void Expression_Enum::set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_enum_kind();
  if (unspecified) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Enum_Empty>::GetOwningArena(unspecified);
    if (message_arena != submessage_arena) {
      unspecified = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unspecified, submessage_arena);
    }
    set_has_unspecified();
    enum_kind_.unspecified_ = unspecified;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Enum.unspecified)
}
Expression_Enum::Expression_Enum(::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.Expression.Enum)
}
Expression_Enum::Expression_Enum(const Expression_Enum& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_enum_kind();
  switch (from.enum_kind_case()) {
    case kSpecified: {
      _internal_set_specified(from._internal_specified());
      break;
    }
    case kUnspecified: {
      _internal_mutable_unspecified()->::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified());
      break;
    }
    case ENUM_KIND_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum)
}

inline void Expression_Enum::SharedCtor() {
clear_has_enum_kind();
}

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

inline void Expression_Enum::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_enum_kind()) {
    clear_enum_kind();
  }
}

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

void Expression_Enum::clear_enum_kind() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Enum)
  switch (enum_kind_case()) {
    case kSpecified: {
      enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kUnspecified: {
      if (GetArenaForAllocation() == nullptr) {
        delete enum_kind_.unspecified_;
      }
      break;
    }
    case ENUM_KIND_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = ENUM_KIND_NOT_SET;
}


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

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

const char* Expression_Enum::_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 specified = 1 [json_name = "specified"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_specified();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Enum.specified"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Enum.Empty unspecified = 2 [json_name = "unspecified"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_unspecified(), 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* Expression_Enum::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Enum)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string specified = 1 [json_name = "specified"];
  if (_internal_has_specified()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_specified().data(), static_cast<int>(this->_internal_specified().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.Expression.Enum.specified");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_specified(), target);
  }

  // .substrait.Expression.Enum.Empty unspecified = 2 [json_name = "unspecified"];
  if (_internal_has_unspecified()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::unspecified(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.Expression.Enum)
  return target;
}

size_t Expression_Enum::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Enum)
  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 (enum_kind_case()) {
    // string specified = 1 [json_name = "specified"];
    case kSpecified: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_specified());
      break;
    }
    // .substrait.Expression.Enum.Empty unspecified = 2 [json_name = "unspecified"];
    case kUnspecified: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *enum_kind_.unspecified_);
      break;
    }
    case ENUM_KIND_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  switch (from.enum_kind_case()) {
    case kSpecified: {
      _internal_set_specified(from._internal_specified());
      break;
    }
    case kUnspecified: {
      _internal_mutable_unspecified()->::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified());
      break;
    }
    case ENUM_KIND_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[28]);
}

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

class Expression_Literal_VarChar::_Internal {
 public:
};

Expression_Literal_VarChar::Expression_Literal_VarChar(::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.Expression.Literal.VarChar)
}
Expression_Literal_VarChar::Expression_Literal_VarChar(const Expression_Literal_VarChar& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_value().empty()) {
    value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), 
      GetArenaForAllocation());
  }
  length_ = from.length_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.VarChar)
}

inline void Expression_Literal_VarChar::SharedCtor() {
value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
length_ = 0u;
}

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

inline void Expression_Literal_VarChar::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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

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

  value_.ClearToEmpty();
  length_ = 0u;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Literal_VarChar::_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 value = 1 [json_name = "value"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_value();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.VarChar.value"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint32 length = 2 [json_name = "length"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* Expression_Literal_VarChar::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.VarChar)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string value = 1 [json_name = "value"];
  if (!this->_internal_value().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.Expression.Literal.VarChar.value");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_value(), target);
  }

  // uint32 length = 2 [json_name = "length"];
  if (this->_internal_length() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_length(), 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.Expression.Literal.VarChar)
  return target;
}

size_t Expression_Literal_VarChar::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.VarChar)
  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 value = 1 [json_name = "value"];
  if (!this->_internal_value().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_value());
  }

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

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (!from._internal_value().empty()) {
    _internal_set_value(from._internal_value());
  }
  if (from._internal_length() != 0) {
    _internal_set_length(from._internal_length());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_Literal_VarChar::InternalSwap(Expression_Literal_VarChar* 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(),
      &value_, lhs_arena,
      &other->value_, rhs_arena
  );
  swap(length_, other->length_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_VarChar::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[29]);
}

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

class Expression_Literal_Decimal::_Internal {
 public:
};

Expression_Literal_Decimal::Expression_Literal_Decimal(::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.Expression.Literal.Decimal)
}
Expression_Literal_Decimal::Expression_Literal_Decimal(const Expression_Literal_Decimal& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_value().empty()) {
    value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), 
      GetArenaForAllocation());
  }
  ::memcpy(&precision_, &from.precision_,
    static_cast<size_t>(reinterpret_cast<char*>(&scale_) -
    reinterpret_cast<char*>(&precision_)) + sizeof(scale_));
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Decimal)
}

inline void Expression_Literal_Decimal::SharedCtor() {
value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&precision_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&scale_) -
    reinterpret_cast<char*>(&precision_)) + sizeof(scale_));
}

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

inline void Expression_Literal_Decimal::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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

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

  value_.ClearToEmpty();
  ::memset(&precision_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&scale_) -
      reinterpret_cast<char*>(&precision_)) + sizeof(scale_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Literal_Decimal::_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) {
      // bytes value = 1 [json_name = "value"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_value();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 precision = 2 [json_name = "precision"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 scale = 3 [json_name = "scale"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* Expression_Literal_Decimal::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Decimal)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bytes value = 1 [json_name = "value"];
  if (!this->_internal_value().empty()) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_value(), target);
  }

  // int32 precision = 2 [json_name = "precision"];
  if (this->_internal_precision() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target);
  }

  // int32 scale = 3 [json_name = "scale"];
  if (this->_internal_scale() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_scale(), 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.Expression.Literal.Decimal)
  return target;
}

size_t Expression_Literal_Decimal::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Decimal)
  size_t total_size = 0;

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

  // bytes value = 1 [json_name = "value"];
  if (!this->_internal_value().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_value());
  }

  // int32 precision = 2 [json_name = "precision"];
  if (this->_internal_precision() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_precision());
  }

  // int32 scale = 3 [json_name = "scale"];
  if (this->_internal_scale() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_scale());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (!from._internal_value().empty()) {
    _internal_set_value(from._internal_value());
  }
  if (from._internal_precision() != 0) {
    _internal_set_precision(from._internal_precision());
  }
  if (from._internal_scale() != 0) {
    _internal_set_scale(from._internal_scale());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_Literal_Decimal::InternalSwap(Expression_Literal_Decimal* 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(),
      &value_, lhs_arena,
      &other->value_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Expression_Literal_Decimal, scale_)
      + sizeof(Expression_Literal_Decimal::scale_)
      - PROTOBUF_FIELD_OFFSET(Expression_Literal_Decimal, precision_)>(
          reinterpret_cast<char*>(&precision_),
          reinterpret_cast<char*>(&other->precision_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Decimal::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[30]);
}

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

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

const ::substrait::Expression_Literal&
Expression_Literal_Map_KeyValue::_Internal::key(const Expression_Literal_Map_KeyValue* msg) {
  return *msg->key_;
}
const ::substrait::Expression_Literal&
Expression_Literal_Map_KeyValue::_Internal::value(const Expression_Literal_Map_KeyValue* msg) {
  return *msg->value_;
}
Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(::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.Expression.Literal.Map.KeyValue)
}
Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_key()) {
    key_ = new ::substrait::Expression_Literal(*from.key_);
  } else {
    key_ = nullptr;
  }
  if (from._internal_has_value()) {
    value_ = new ::substrait::Expression_Literal(*from.value_);
  } else {
    value_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map.KeyValue)
}

inline void Expression_Literal_Map_KeyValue::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*>(&value_) -
    reinterpret_cast<char*>(&key_)) + sizeof(value_));
}

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

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

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

void Expression_Literal_Map_KeyValue::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Map.KeyValue)
  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;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Literal_Map_KeyValue::_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.Expression.Literal 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.Expression.Literal 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;
      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* Expression_Literal_Map_KeyValue::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map.KeyValue)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.Literal 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.Expression.Literal 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);
  }

  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.Expression.Literal.Map.KeyValue)
  return target;
}

size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map.KeyValue)
  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.Expression.Literal key = 1 [json_name = "key"];
  if (this->_internal_has_key()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *key_);
  }

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

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


void Expression_Literal_Map_KeyValue::MergeFrom(const Expression_Literal_Map_KeyValue& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Map.KeyValue)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_key()) {
    _internal_mutable_key()->::substrait::Expression_Literal::MergeFrom(from._internal_key());
  }
  if (from._internal_has_value()) {
    _internal_mutable_value()->::substrait::Expression_Literal::MergeFrom(from._internal_value());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_Literal_Map_KeyValue::CopyFrom(const Expression_Literal_Map_KeyValue& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Map.KeyValue)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map_KeyValue::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[31]);
}

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

class Expression_Literal_Map::_Internal {
 public:
};

Expression_Literal_Map::Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  key_values_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Map)
}
Expression_Literal_Map::Expression_Literal_Map(const Expression_Literal_Map& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      key_values_(from.key_values_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map)
}

inline void Expression_Literal_Map::SharedCtor() {
}

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

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

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

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

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

const char* Expression_Literal_Map::_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.Expression.Literal.Map.KeyValue key_values = 1 [json_name = "keyValues"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_key_values(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_Literal_Map::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1 [json_name = "keyValues"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_key_values_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_key_values(i), 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.Expression.Literal.Map)
  return target;
}

size_t Expression_Literal_Map::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map)
  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.Expression.Literal.Map.KeyValue key_values = 1 [json_name = "keyValues"];
  total_size += 1UL * this->_internal_key_values_size();
  for (const auto& msg : this->key_values_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  key_values_.MergeFrom(from.key_values_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_Literal_Map::InternalSwap(Expression_Literal_Map* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  key_values_.InternalSwap(&other->key_values_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[32]);
}

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

class Expression_Literal_IntervalYearToMonth::_Internal {
 public:
};

Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(::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.Expression.Literal.IntervalYearToMonth)
}
Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&years_, &from.years_,
    static_cast<size_t>(reinterpret_cast<char*>(&months_) -
    reinterpret_cast<char*>(&years_)) + sizeof(months_));
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalYearToMonth)
}

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

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

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

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

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

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

const char* Expression_Literal_IntervalYearToMonth::_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) {
      // int32 years = 1 [json_name = "years"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          years_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 months = 2 [json_name = "months"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          months_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* Expression_Literal_IntervalYearToMonth::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalYearToMonth)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 years = 1 [json_name = "years"];
  if (this->_internal_years() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_years(), target);
  }

  // int32 months = 2 [json_name = "months"];
  if (this->_internal_months() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_months(), 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.Expression.Literal.IntervalYearToMonth)
  return target;
}

size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalYearToMonth)
  size_t total_size = 0;

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

  // int32 years = 1 [json_name = "years"];
  if (this->_internal_years() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_years());
  }

  // int32 months = 2 [json_name = "months"];
  if (this->_internal_months() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_months());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_years() != 0) {
    _internal_set_years(from._internal_years());
  }
  if (from._internal_months() != 0) {
    _internal_set_months(from._internal_months());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalYearToMonth::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[33]);
}

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

class Expression_Literal_IntervalDayToSecond::_Internal {
 public:
};

Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(::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.Expression.Literal.IntervalDayToSecond)
}
Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&days_, &from.days_,
    static_cast<size_t>(reinterpret_cast<char*>(&seconds_) -
    reinterpret_cast<char*>(&days_)) + sizeof(seconds_));
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalDayToSecond)
}

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

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

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

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

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

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

const char* Expression_Literal_IntervalDayToSecond::_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) {
      // int32 days = 1 [json_name = "days"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          days_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 seconds = 2 [json_name = "seconds"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* Expression_Literal_IntervalDayToSecond::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalDayToSecond)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 days = 1 [json_name = "days"];
  if (this->_internal_days() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_days(), target);
  }

  // int32 seconds = 2 [json_name = "seconds"];
  if (this->_internal_seconds() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_seconds(), 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.Expression.Literal.IntervalDayToSecond)
  return target;
}

size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalDayToSecond)
  size_t total_size = 0;

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

  // int32 days = 1 [json_name = "days"];
  if (this->_internal_days() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_days());
  }

  // int32 seconds = 2 [json_name = "seconds"];
  if (this->_internal_seconds() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_seconds());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_days() != 0) {
    _internal_set_days(from._internal_days());
  }
  if (from._internal_seconds() != 0) {
    _internal_set_seconds(from._internal_seconds());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalDayToSecond::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[34]);
}

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

class Expression_Literal_Struct::_Internal {
 public:
};

Expression_Literal_Struct::Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  fields_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Struct)
}
Expression_Literal_Struct::Expression_Literal_Struct(const Expression_Literal_Struct& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      fields_(from.fields_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Struct)
}

inline void Expression_Literal_Struct::SharedCtor() {
}

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

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

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

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

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

const char* Expression_Literal_Struct::_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.Expression.Literal fields = 1 [json_name = "fields"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_fields(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_Literal_Struct::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Struct)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression.Literal fields = 1 [json_name = "fields"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_fields_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_fields(i), 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.Expression.Literal.Struct)
  return target;
}

size_t Expression_Literal_Struct::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Struct)
  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.Expression.Literal fields = 1 [json_name = "fields"];
  total_size += 1UL * this->_internal_fields_size();
  for (const auto& msg : this->fields_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  fields_.MergeFrom(from.fields_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_Literal_Struct::InternalSwap(Expression_Literal_Struct* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  fields_.InternalSwap(&other->fields_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Struct::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[35]);
}

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

class Expression_Literal_List::_Internal {
 public:
};

Expression_Literal_List::Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  values_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.List)
}
Expression_Literal_List::Expression_Literal_List(const Expression_Literal_List& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      values_(from.values_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.List)
}

inline void Expression_Literal_List::SharedCtor() {
}

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

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

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

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

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

const char* Expression_Literal_List::_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.Expression.Literal values = 1 [json_name = "values"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_values(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_Literal_List::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.List)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression.Literal values = 1 [json_name = "values"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_values_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_values(i), 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.Expression.Literal.List)
  return target;
}

size_t Expression_Literal_List::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.List)
  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.Expression.Literal values = 1 [json_name = "values"];
  total_size += 1UL * this->_internal_values_size();
  for (const auto& msg : this->values_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  values_.MergeFrom(from.values_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_Literal_List::InternalSwap(Expression_Literal_List* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  values_.InternalSwap(&other->values_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_List::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[36]);
}

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

class Expression_Literal::_Internal {
 public:
  static const ::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month(const Expression_Literal* msg);
  static const ::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second(const Expression_Literal* msg);
  static const ::substrait::Expression_Literal_VarChar& var_char(const Expression_Literal* msg);
  static const ::substrait::Expression_Literal_Decimal& decimal(const Expression_Literal* msg);
  static const ::substrait::Expression_Literal_Struct& struct_(const Expression_Literal* msg);
  static const ::substrait::Expression_Literal_Map& map(const Expression_Literal* msg);
  static const ::substrait::Type& null(const Expression_Literal* msg);
  static const ::substrait::Expression_Literal_List& list(const Expression_Literal* msg);
  static const ::substrait::Type_List& empty_list(const Expression_Literal* msg);
  static const ::substrait::Type_Map& empty_map(const Expression_Literal* msg);
};

const ::substrait::Expression_Literal_IntervalYearToMonth&
Expression_Literal::_Internal::interval_year_to_month(const Expression_Literal* msg) {
  return *msg->literal_type_.interval_year_to_month_;
}
const ::substrait::Expression_Literal_IntervalDayToSecond&
Expression_Literal::_Internal::interval_day_to_second(const Expression_Literal* msg) {
  return *msg->literal_type_.interval_day_to_second_;
}
const ::substrait::Expression_Literal_VarChar&
Expression_Literal::_Internal::var_char(const Expression_Literal* msg) {
  return *msg->literal_type_.var_char_;
}
const ::substrait::Expression_Literal_Decimal&
Expression_Literal::_Internal::decimal(const Expression_Literal* msg) {
  return *msg->literal_type_.decimal_;
}
const ::substrait::Expression_Literal_Struct&
Expression_Literal::_Internal::struct_(const Expression_Literal* msg) {
  return *msg->literal_type_.struct__;
}
const ::substrait::Expression_Literal_Map&
Expression_Literal::_Internal::map(const Expression_Literal* msg) {
  return *msg->literal_type_.map_;
}
const ::substrait::Type&
Expression_Literal::_Internal::null(const Expression_Literal* msg) {
  return *msg->literal_type_.null_;
}
const ::substrait::Expression_Literal_List&
Expression_Literal::_Internal::list(const Expression_Literal* msg) {
  return *msg->literal_type_.list_;
}
const ::substrait::Type_List&
Expression_Literal::_Internal::empty_list(const Expression_Literal* msg) {
  return *msg->literal_type_.empty_list_;
}
const ::substrait::Type_Map&
Expression_Literal::_Internal::empty_map(const Expression_Literal* msg) {
  return *msg->literal_type_.empty_map_;
}
void Expression_Literal::set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (interval_year_to_month) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_IntervalYearToMonth>::GetOwningArena(interval_year_to_month);
    if (message_arena != submessage_arena) {
      interval_year_to_month = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interval_year_to_month, submessage_arena);
    }
    set_has_interval_year_to_month();
    literal_type_.interval_year_to_month_ = interval_year_to_month;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_year_to_month)
}
void Expression_Literal::set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (interval_day_to_second) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_IntervalDayToSecond>::GetOwningArena(interval_day_to_second);
    if (message_arena != submessage_arena) {
      interval_day_to_second = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interval_day_to_second, submessage_arena);
    }
    set_has_interval_day_to_second();
    literal_type_.interval_day_to_second_ = interval_day_to_second;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_day_to_second)
}
void Expression_Literal::set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (var_char) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_VarChar>::GetOwningArena(var_char);
    if (message_arena != submessage_arena) {
      var_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, var_char, submessage_arena);
    }
    set_has_var_char();
    literal_type_.var_char_ = var_char;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.var_char)
}
void Expression_Literal::set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (decimal) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Decimal>::GetOwningArena(decimal);
    if (message_arena != submessage_arena) {
      decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, decimal, submessage_arena);
    }
    set_has_decimal();
    literal_type_.decimal_ = decimal;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.decimal)
}
void Expression_Literal::set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (struct_) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Struct>::GetOwningArena(struct_);
    if (message_arena != submessage_arena) {
      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, struct_, submessage_arena);
    }
    set_has_struct_();
    literal_type_.struct__ = struct_;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.struct)
}
void Expression_Literal::set_allocated_map(::substrait::Expression_Literal_Map* map) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (map) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Map>::GetOwningArena(map);
    if (message_arena != submessage_arena) {
      map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, map, submessage_arena);
    }
    set_has_map();
    literal_type_.map_ = map;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.map)
}
void Expression_Literal::set_allocated_null(::substrait::Type* null) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (null) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(null));
    if (message_arena != submessage_arena) {
      null = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, null, submessage_arena);
    }
    set_has_null();
    literal_type_.null_ = null;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.null)
}
void Expression_Literal::clear_null() {
  if (_internal_has_null()) {
    if (GetArenaForAllocation() == nullptr) {
      delete literal_type_.null_;
    }
    clear_has_literal_type();
  }
}
void Expression_Literal::set_allocated_list(::substrait::Expression_Literal_List* list) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (list) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_List>::GetOwningArena(list);
    if (message_arena != submessage_arena) {
      list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, list, submessage_arena);
    }
    set_has_list();
    literal_type_.list_ = list;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.list)
}
void Expression_Literal::set_allocated_empty_list(::substrait::Type_List* empty_list) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (empty_list) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_list));
    if (message_arena != submessage_arena) {
      empty_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, empty_list, submessage_arena);
    }
    set_has_empty_list();
    literal_type_.empty_list_ = empty_list;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.empty_list)
}
void Expression_Literal::clear_empty_list() {
  if (_internal_has_empty_list()) {
    if (GetArenaForAllocation() == nullptr) {
      delete literal_type_.empty_list_;
    }
    clear_has_literal_type();
  }
}
void Expression_Literal::set_allocated_empty_map(::substrait::Type_Map* empty_map) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_literal_type();
  if (empty_map) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_map));
    if (message_arena != submessage_arena) {
      empty_map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, empty_map, submessage_arena);
    }
    set_has_empty_map();
    literal_type_.empty_map_ = empty_map;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.empty_map)
}
void Expression_Literal::clear_empty_map() {
  if (_internal_has_empty_map()) {
    if (GetArenaForAllocation() == nullptr) {
      delete literal_type_.empty_map_;
    }
    clear_has_literal_type();
  }
}
Expression_Literal::Expression_Literal(::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.Expression.Literal)
}
Expression_Literal::Expression_Literal(const Expression_Literal& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  nullable_ = from.nullable_;
  clear_has_literal_type();
  switch (from.literal_type_case()) {
    case kBoolean: {
      _internal_set_boolean(from._internal_boolean());
      break;
    }
    case kI8: {
      _internal_set_i8(from._internal_i8());
      break;
    }
    case kI16: {
      _internal_set_i16(from._internal_i16());
      break;
    }
    case kI32: {
      _internal_set_i32(from._internal_i32());
      break;
    }
    case kI64: {
      _internal_set_i64(from._internal_i64());
      break;
    }
    case kFp32: {
      _internal_set_fp32(from._internal_fp32());
      break;
    }
    case kFp64: {
      _internal_set_fp64(from._internal_fp64());
      break;
    }
    case kString: {
      _internal_set_string(from._internal_string());
      break;
    }
    case kBinary: {
      _internal_set_binary(from._internal_binary());
      break;
    }
    case kTimestamp: {
      _internal_set_timestamp(from._internal_timestamp());
      break;
    }
    case kDate: {
      _internal_set_date(from._internal_date());
      break;
    }
    case kTime: {
      _internal_set_time(from._internal_time());
      break;
    }
    case kIntervalYearToMonth: {
      _internal_mutable_interval_year_to_month()->::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month());
      break;
    }
    case kIntervalDayToSecond: {
      _internal_mutable_interval_day_to_second()->::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second());
      break;
    }
    case kFixedChar: {
      _internal_set_fixed_char(from._internal_fixed_char());
      break;
    }
    case kVarChar: {
      _internal_mutable_var_char()->::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char());
      break;
    }
    case kFixedBinary: {
      _internal_set_fixed_binary(from._internal_fixed_binary());
      break;
    }
    case kDecimal: {
      _internal_mutable_decimal()->::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal());
      break;
    }
    case kStruct: {
      _internal_mutable_struct_()->::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_());
      break;
    }
    case kMap: {
      _internal_mutable_map()->::substrait::Expression_Literal_Map::MergeFrom(from._internal_map());
      break;
    }
    case kTimestampTz: {
      _internal_set_timestamp_tz(from._internal_timestamp_tz());
      break;
    }
    case kUuid: {
      _internal_set_uuid(from._internal_uuid());
      break;
    }
    case kNull: {
      _internal_mutable_null()->::substrait::Type::MergeFrom(from._internal_null());
      break;
    }
    case kList: {
      _internal_mutable_list()->::substrait::Expression_Literal_List::MergeFrom(from._internal_list());
      break;
    }
    case kEmptyList: {
      _internal_mutable_empty_list()->::substrait::Type_List::MergeFrom(from._internal_empty_list());
      break;
    }
    case kEmptyMap: {
      _internal_mutable_empty_map()->::substrait::Type_Map::MergeFrom(from._internal_empty_map());
      break;
    }
    case LITERAL_TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal)
}

inline void Expression_Literal::SharedCtor() {
nullable_ = false;
clear_has_literal_type();
}

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

inline void Expression_Literal::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_literal_type()) {
    clear_literal_type();
  }
}

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

void Expression_Literal::clear_literal_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Literal)
  switch (literal_type_case()) {
    case kBoolean: {
      // No need to clear
      break;
    }
    case kI8: {
      // No need to clear
      break;
    }
    case kI16: {
      // No need to clear
      break;
    }
    case kI32: {
      // No need to clear
      break;
    }
    case kI64: {
      // No need to clear
      break;
    }
    case kFp32: {
      // No need to clear
      break;
    }
    case kFp64: {
      // No need to clear
      break;
    }
    case kString: {
      literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kBinary: {
      literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kTimestamp: {
      // No need to clear
      break;
    }
    case kDate: {
      // No need to clear
      break;
    }
    case kTime: {
      // No need to clear
      break;
    }
    case kIntervalYearToMonth: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.interval_year_to_month_;
      }
      break;
    }
    case kIntervalDayToSecond: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.interval_day_to_second_;
      }
      break;
    }
    case kFixedChar: {
      literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kVarChar: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.var_char_;
      }
      break;
    }
    case kFixedBinary: {
      literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kDecimal: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.decimal_;
      }
      break;
    }
    case kStruct: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.struct__;
      }
      break;
    }
    case kMap: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.map_;
      }
      break;
    }
    case kTimestampTz: {
      // No need to clear
      break;
    }
    case kUuid: {
      literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kNull: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.null_;
      }
      break;
    }
    case kList: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.list_;
      }
      break;
    }
    case kEmptyList: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.empty_list_;
      }
      break;
    }
    case kEmptyMap: {
      if (GetArenaForAllocation() == nullptr) {
        delete literal_type_.empty_map_;
      }
      break;
    }
    case LITERAL_TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = LITERAL_TYPE_NOT_SET;
}


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

  nullable_ = false;
  clear_literal_type();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Literal::_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) {
      // bool boolean = 1 [json_name = "boolean"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _internal_set_boolean(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 i8 = 2 [json_name = "i8"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _internal_set_i8(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 i16 = 3 [json_name = "i16"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _internal_set_i16(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 i32 = 5 [json_name = "i32"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _internal_set_i32(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 i64 = 7 [json_name = "i64"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          _internal_set_i64(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // float fp32 = 10 [json_name = "fp32"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 85)) {
          _internal_set_fp32(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else
          goto handle_unusual;
        continue;
      // double fp64 = 11 [json_name = "fp64"];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 89)) {
          _internal_set_fp64(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // string string = 12 [json_name = "string"];
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
          auto str = _internal_mutable_string();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.string"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes binary = 13 [json_name = "binary"];
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
          auto str = _internal_mutable_binary();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 timestamp = 14 [json_name = "timestamp"];
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
          _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 date = 16 [json_name = "date"];
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
          _internal_set_date(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 time = 17 [json_name = "time"];
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 136)) {
          _internal_set_time(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19 [json_name = "intervalYearToMonth"];
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
          ptr = ctx->ParseMessage(_internal_mutable_interval_year_to_month(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20 [json_name = "intervalDayToSecond"];
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_interval_day_to_second(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string fixed_char = 21 [json_name = "fixedChar"];
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
          auto str = _internal_mutable_fixed_char();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.fixed_char"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Literal.VarChar var_char = 22 [json_name = "varChar"];
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
          ptr = ctx->ParseMessage(_internal_mutable_var_char(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes fixed_binary = 23 [json_name = "fixedBinary"];
      case 23:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
          auto str = _internal_mutable_fixed_binary();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Literal.Decimal 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.Expression.Literal.Struct 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.Expression.Literal.Map map = 26 [json_name = "map"];
      case 26:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 210)) {
          ptr = ctx->ParseMessage(_internal_mutable_map(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 timestamp_tz = 27 [json_name = "timestampTz"];
      case 27:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
          _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bytes uuid = 28 [json_name = "uuid"];
      case 28:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
          auto str = _internal_mutable_uuid();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type null = 29 [json_name = "null"];
      case 29:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
          ptr = ctx->ParseMessage(_internal_mutable_null(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Literal.List list = 30 [json_name = "list"];
      case 30:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 242)) {
          ptr = ctx->ParseMessage(_internal_mutable_list(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.List empty_list = 31 [json_name = "emptyList"];
      case 31:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 250)) {
          ptr = ctx->ParseMessage(_internal_mutable_empty_list(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type.Map empty_map = 32 [json_name = "emptyMap"];
      case 32:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
          ptr = ctx->ParseMessage(_internal_mutable_empty_map(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool nullable = 50 [json_name = "nullable"];
      case 50:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
          nullable_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&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* Expression_Literal::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bool boolean = 1 [json_name = "boolean"];
  if (_internal_has_boolean()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_boolean(), target);
  }

  // int32 i8 = 2 [json_name = "i8"];
  if (_internal_has_i8()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_i8(), target);
  }

  // int32 i16 = 3 [json_name = "i16"];
  if (_internal_has_i16()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_i16(), target);
  }

  // int32 i32 = 5 [json_name = "i32"];
  if (_internal_has_i32()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_i32(), target);
  }

  // int64 i64 = 7 [json_name = "i64"];
  if (_internal_has_i64()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_i64(), target);
  }

  // float fp32 = 10 [json_name = "fp32"];
  if (_internal_has_fp32()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_fp32(), target);
  }

  // double fp64 = 11 [json_name = "fp64"];
  if (_internal_has_fp64()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(11, this->_internal_fp64(), target);
  }

  // string string = 12 [json_name = "string"];
  if (_internal_has_string()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_string().data(), static_cast<int>(this->_internal_string().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.Expression.Literal.string");
    target = stream->WriteStringMaybeAliased(
        12, this->_internal_string(), target);
  }

  // bytes binary = 13 [json_name = "binary"];
  if (_internal_has_binary()) {
    target = stream->WriteBytesMaybeAliased(
        13, this->_internal_binary(), target);
  }

  // int64 timestamp = 14 [json_name = "timestamp"];
  if (_internal_has_timestamp()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(14, this->_internal_timestamp(), target);
  }

  // int32 date = 16 [json_name = "date"];
  if (_internal_has_date()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(16, this->_internal_date(), target);
  }

  // int64 time = 17 [json_name = "time"];
  if (_internal_has_time()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(17, this->_internal_time(), target);
  }

  // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19 [json_name = "intervalYearToMonth"];
  if (_internal_has_interval_year_to_month()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        19, _Internal::interval_year_to_month(this), target, stream);
  }

  // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20 [json_name = "intervalDayToSecond"];
  if (_internal_has_interval_day_to_second()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        20, _Internal::interval_day_to_second(this), target, stream);
  }

  // string fixed_char = 21 [json_name = "fixedChar"];
  if (_internal_has_fixed_char()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_fixed_char().data(), static_cast<int>(this->_internal_fixed_char().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.Expression.Literal.fixed_char");
    target = stream->WriteStringMaybeAliased(
        21, this->_internal_fixed_char(), target);
  }

  // .substrait.Expression.Literal.VarChar var_char = 22 [json_name = "varChar"];
  if (_internal_has_var_char()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        22, _Internal::var_char(this), target, stream);
  }

  // bytes fixed_binary = 23 [json_name = "fixedBinary"];
  if (_internal_has_fixed_binary()) {
    target = stream->WriteBytesMaybeAliased(
        23, this->_internal_fixed_binary(), target);
  }

  // .substrait.Expression.Literal.Decimal 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.Expression.Literal.Struct 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.Expression.Literal.Map map = 26 [json_name = "map"];
  if (_internal_has_map()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        26, _Internal::map(this), target, stream);
  }

  // int64 timestamp_tz = 27 [json_name = "timestampTz"];
  if (_internal_has_timestamp_tz()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(27, this->_internal_timestamp_tz(), target);
  }

  // bytes uuid = 28 [json_name = "uuid"];
  if (_internal_has_uuid()) {
    target = stream->WriteBytesMaybeAliased(
        28, this->_internal_uuid(), target);
  }

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

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

  // .substrait.Type.List empty_list = 31 [json_name = "emptyList"];
  if (_internal_has_empty_list()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        31, _Internal::empty_list(this), target, stream);
  }

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

  // bool nullable = 50 [json_name = "nullable"];
  if (this->_internal_nullable() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(50, this->_internal_nullable(), 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.Expression.Literal)
  return target;
}

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

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

  // bool nullable = 50 [json_name = "nullable"];
  if (this->_internal_nullable() != 0) {
    total_size += 2 + 1;
  }

  switch (literal_type_case()) {
    // bool boolean = 1 [json_name = "boolean"];
    case kBoolean: {
      total_size += 1 + 1;
      break;
    }
    // int32 i8 = 2 [json_name = "i8"];
    case kI8: {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i8());
      break;
    }
    // int32 i16 = 3 [json_name = "i16"];
    case kI16: {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i16());
      break;
    }
    // int32 i32 = 5 [json_name = "i32"];
    case kI32: {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i32());
      break;
    }
    // int64 i64 = 7 [json_name = "i64"];
    case kI64: {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_i64());
      break;
    }
    // float fp32 = 10 [json_name = "fp32"];
    case kFp32: {
      total_size += 1 + 4;
      break;
    }
    // double fp64 = 11 [json_name = "fp64"];
    case kFp64: {
      total_size += 1 + 8;
      break;
    }
    // string string = 12 [json_name = "string"];
    case kString: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_string());
      break;
    }
    // bytes binary = 13 [json_name = "binary"];
    case kBinary: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_binary());
      break;
    }
    // int64 timestamp = 14 [json_name = "timestamp"];
    case kTimestamp: {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp());
      break;
    }
    // int32 date = 16 [json_name = "date"];
    case kDate: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_date());
      break;
    }
    // int64 time = 17 [json_name = "time"];
    case kTime: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_time());
      break;
    }
    // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19 [json_name = "intervalYearToMonth"];
    case kIntervalYearToMonth: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.interval_year_to_month_);
      break;
    }
    // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20 [json_name = "intervalDayToSecond"];
    case kIntervalDayToSecond: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.interval_day_to_second_);
      break;
    }
    // string fixed_char = 21 [json_name = "fixedChar"];
    case kFixedChar: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_fixed_char());
      break;
    }
    // .substrait.Expression.Literal.VarChar var_char = 22 [json_name = "varChar"];
    case kVarChar: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.var_char_);
      break;
    }
    // bytes fixed_binary = 23 [json_name = "fixedBinary"];
    case kFixedBinary: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_fixed_binary());
      break;
    }
    // .substrait.Expression.Literal.Decimal decimal = 24 [json_name = "decimal"];
    case kDecimal: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.decimal_);
      break;
    }
    // .substrait.Expression.Literal.Struct struct = 25 [json_name = "struct"];
    case kStruct: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.struct__);
      break;
    }
    // .substrait.Expression.Literal.Map map = 26 [json_name = "map"];
    case kMap: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.map_);
      break;
    }
    // int64 timestamp_tz = 27 [json_name = "timestampTz"];
    case kTimestampTz: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_timestamp_tz());
      break;
    }
    // bytes uuid = 28 [json_name = "uuid"];
    case kUuid: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_uuid());
      break;
    }
    // .substrait.Type null = 29 [json_name = "null"];
    case kNull: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.null_);
      break;
    }
    // .substrait.Expression.Literal.List list = 30 [json_name = "list"];
    case kList: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.list_);
      break;
    }
    // .substrait.Type.List empty_list = 31 [json_name = "emptyList"];
    case kEmptyList: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.empty_list_);
      break;
    }
    // .substrait.Type.Map empty_map = 32 [json_name = "emptyMap"];
    case kEmptyMap: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *literal_type_.empty_map_);
      break;
    }
    case LITERAL_TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_nullable() != 0) {
    _internal_set_nullable(from._internal_nullable());
  }
  switch (from.literal_type_case()) {
    case kBoolean: {
      _internal_set_boolean(from._internal_boolean());
      break;
    }
    case kI8: {
      _internal_set_i8(from._internal_i8());
      break;
    }
    case kI16: {
      _internal_set_i16(from._internal_i16());
      break;
    }
    case kI32: {
      _internal_set_i32(from._internal_i32());
      break;
    }
    case kI64: {
      _internal_set_i64(from._internal_i64());
      break;
    }
    case kFp32: {
      _internal_set_fp32(from._internal_fp32());
      break;
    }
    case kFp64: {
      _internal_set_fp64(from._internal_fp64());
      break;
    }
    case kString: {
      _internal_set_string(from._internal_string());
      break;
    }
    case kBinary: {
      _internal_set_binary(from._internal_binary());
      break;
    }
    case kTimestamp: {
      _internal_set_timestamp(from._internal_timestamp());
      break;
    }
    case kDate: {
      _internal_set_date(from._internal_date());
      break;
    }
    case kTime: {
      _internal_set_time(from._internal_time());
      break;
    }
    case kIntervalYearToMonth: {
      _internal_mutable_interval_year_to_month()->::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month());
      break;
    }
    case kIntervalDayToSecond: {
      _internal_mutable_interval_day_to_second()->::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second());
      break;
    }
    case kFixedChar: {
      _internal_set_fixed_char(from._internal_fixed_char());
      break;
    }
    case kVarChar: {
      _internal_mutable_var_char()->::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char());
      break;
    }
    case kFixedBinary: {
      _internal_set_fixed_binary(from._internal_fixed_binary());
      break;
    }
    case kDecimal: {
      _internal_mutable_decimal()->::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal());
      break;
    }
    case kStruct: {
      _internal_mutable_struct_()->::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_());
      break;
    }
    case kMap: {
      _internal_mutable_map()->::substrait::Expression_Literal_Map::MergeFrom(from._internal_map());
      break;
    }
    case kTimestampTz: {
      _internal_set_timestamp_tz(from._internal_timestamp_tz());
      break;
    }
    case kUuid: {
      _internal_set_uuid(from._internal_uuid());
      break;
    }
    case kNull: {
      _internal_mutable_null()->::substrait::Type::MergeFrom(from._internal_null());
      break;
    }
    case kList: {
      _internal_mutable_list()->::substrait::Expression_Literal_List::MergeFrom(from._internal_list());
      break;
    }
    case kEmptyList: {
      _internal_mutable_empty_list()->::substrait::Type_List::MergeFrom(from._internal_empty_list());
      break;
    }
    case kEmptyMap: {
      _internal_mutable_empty_map()->::substrait::Type_Map::MergeFrom(from._internal_empty_map());
      break;
    }
    case LITERAL_TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[37]);
}

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

class Expression_ScalarFunction::_Internal {
 public:
  static const ::substrait::Type& output_type(const Expression_ScalarFunction* msg);
};

const ::substrait::Type&
Expression_ScalarFunction::_Internal::output_type(const Expression_ScalarFunction* msg) {
  return *msg->output_type_;
}
void Expression_ScalarFunction::clear_output_type() {
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
}
Expression_ScalarFunction::Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  args_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.ScalarFunction)
}
Expression_ScalarFunction::Expression_ScalarFunction(const Expression_ScalarFunction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      args_(from.args_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_output_type()) {
    output_type_ = new ::substrait::Type(*from.output_type_);
  } else {
    output_type_ = nullptr;
  }
  function_reference_ = from.function_reference_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ScalarFunction)
}

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

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

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

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

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

  args_.Clear();
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
  function_reference_ = 0u;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_ScalarFunction::_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) {
      // uint32 function_reference = 1 [json_name = "functionReference"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.Expression args = 2 [json_name = "args"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_args(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type output_type = 3 [json_name = "outputType"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_output_type(), 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* Expression_ScalarFunction::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ScalarFunction)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 function_reference = 1 [json_name = "functionReference"];
  if (this->_internal_function_reference() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target);
  }

  // repeated .substrait.Expression args = 2 [json_name = "args"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_args_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_args(i), target, stream);
  }

  // .substrait.Type output_type = 3 [json_name = "outputType"];
  if (this->_internal_has_output_type()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::output_type(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.Expression.ScalarFunction)
  return target;
}

size_t Expression_ScalarFunction::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ScalarFunction)
  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.Expression args = 2 [json_name = "args"];
  total_size += 1UL * this->_internal_args_size();
  for (const auto& msg : this->args_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.Type output_type = 3 [json_name = "outputType"];
  if (this->_internal_has_output_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *output_type_);
  }

  // uint32 function_reference = 1 [json_name = "functionReference"];
  if (this->_internal_function_reference() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  args_.MergeFrom(from.args_);
  if (from._internal_has_output_type()) {
    _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type());
  }
  if (from._internal_function_reference() != 0) {
    _internal_set_function_reference(from._internal_function_reference());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_ScalarFunction::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[38]);
}

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

class Expression_WindowFunction_Bound_Preceding::_Internal {
 public:
};

Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(::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.Expression.WindowFunction.Bound.Preceding)
}
Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  offset_ = from.offset_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Preceding)
}

inline void Expression_WindowFunction_Bound_Preceding::SharedCtor() {
offset_ = int64_t{0};
}

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

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

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

void Expression_WindowFunction_Bound_Preceding::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Preceding)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  offset_ = int64_t{0};
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_WindowFunction_Bound_Preceding::_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) {
      // int64 offset = 1 [json_name = "offset"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&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* Expression_WindowFunction_Bound_Preceding::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Preceding)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 offset = 1 [json_name = "offset"];
  if (this->_internal_offset() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), 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.Expression.WindowFunction.Bound.Preceding)
  return target;
}

size_t Expression_WindowFunction_Bound_Preceding::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Preceding)
  size_t total_size = 0;

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

  // int64 offset = 1 [json_name = "offset"];
  if (this->_internal_offset() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


void Expression_WindowFunction_Bound_Preceding::MergeFrom(const Expression_WindowFunction_Bound_Preceding& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Preceding)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_offset() != 0) {
    _internal_set_offset(from._internal_offset());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_WindowFunction_Bound_Preceding::CopyFrom(const Expression_WindowFunction_Bound_Preceding& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Preceding)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void Expression_WindowFunction_Bound_Preceding::InternalSwap(Expression_WindowFunction_Bound_Preceding* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(offset_, other->offset_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Preceding::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[39]);
}

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

class Expression_WindowFunction_Bound_Following::_Internal {
 public:
};

Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(::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.Expression.WindowFunction.Bound.Following)
}
Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(const Expression_WindowFunction_Bound_Following& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  offset_ = from.offset_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Following)
}

inline void Expression_WindowFunction_Bound_Following::SharedCtor() {
offset_ = int64_t{0};
}

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

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

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

void Expression_WindowFunction_Bound_Following::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Following)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  offset_ = int64_t{0};
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_WindowFunction_Bound_Following::_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) {
      // int64 offset = 1 [json_name = "offset"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&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* Expression_WindowFunction_Bound_Following::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Following)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 offset = 1 [json_name = "offset"];
  if (this->_internal_offset() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), 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.Expression.WindowFunction.Bound.Following)
  return target;
}

size_t Expression_WindowFunction_Bound_Following::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Following)
  size_t total_size = 0;

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

  // int64 offset = 1 [json_name = "offset"];
  if (this->_internal_offset() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


void Expression_WindowFunction_Bound_Following::MergeFrom(const Expression_WindowFunction_Bound_Following& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Following)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_offset() != 0) {
    _internal_set_offset(from._internal_offset());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_WindowFunction_Bound_Following::CopyFrom(const Expression_WindowFunction_Bound_Following& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Following)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void Expression_WindowFunction_Bound_Following::InternalSwap(Expression_WindowFunction_Bound_Following* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(offset_, other->offset_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Following::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[40]);
}

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

class Expression_WindowFunction_Bound_CurrentRow::_Internal {
 public:
};

Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow)
}
Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_CurrentRow::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_CurrentRow::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_CurrentRow::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[41]);
}

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

class Expression_WindowFunction_Bound_Unbounded::_Internal {
 public:
};

Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Unbounded)
}
Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Unbounded)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Unbounded::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Unbounded::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Unbounded::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[42]);
}

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

class Expression_WindowFunction_Bound::_Internal {
 public:
  static const ::substrait::Expression_WindowFunction_Bound_Preceding& preceding(const Expression_WindowFunction_Bound* msg);
  static const ::substrait::Expression_WindowFunction_Bound_Following& following(const Expression_WindowFunction_Bound* msg);
  static const ::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row(const Expression_WindowFunction_Bound* msg);
  static const ::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded(const Expression_WindowFunction_Bound* msg);
};

const ::substrait::Expression_WindowFunction_Bound_Preceding&
Expression_WindowFunction_Bound::_Internal::preceding(const Expression_WindowFunction_Bound* msg) {
  return *msg->kind_.preceding_;
}
const ::substrait::Expression_WindowFunction_Bound_Following&
Expression_WindowFunction_Bound::_Internal::following(const Expression_WindowFunction_Bound* msg) {
  return *msg->kind_.following_;
}
const ::substrait::Expression_WindowFunction_Bound_CurrentRow&
Expression_WindowFunction_Bound::_Internal::current_row(const Expression_WindowFunction_Bound* msg) {
  return *msg->kind_.current_row_;
}
const ::substrait::Expression_WindowFunction_Bound_Unbounded&
Expression_WindowFunction_Bound::_Internal::unbounded(const Expression_WindowFunction_Bound* msg) {
  return *msg->kind_.unbounded_;
}
void Expression_WindowFunction_Bound::set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (preceding) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Preceding>::GetOwningArena(preceding);
    if (message_arena != submessage_arena) {
      preceding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, preceding, submessage_arena);
    }
    set_has_preceding();
    kind_.preceding_ = preceding;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.preceding)
}
void Expression_WindowFunction_Bound::set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (following) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Following>::GetOwningArena(following);
    if (message_arena != submessage_arena) {
      following = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, following, submessage_arena);
    }
    set_has_following();
    kind_.following_ = following;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.following)
}
void Expression_WindowFunction_Bound::set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (current_row) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_CurrentRow>::GetOwningArena(current_row);
    if (message_arena != submessage_arena) {
      current_row = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, current_row, submessage_arena);
    }
    set_has_current_row();
    kind_.current_row_ = current_row;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.current_row)
}
void Expression_WindowFunction_Bound::set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (unbounded) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Unbounded>::GetOwningArena(unbounded);
    if (message_arena != submessage_arena) {
      unbounded = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unbounded, submessage_arena);
    }
    set_has_unbounded();
    kind_.unbounded_ = unbounded;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.unbounded)
}
Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(::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.Expression.WindowFunction.Bound)
}
Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(const Expression_WindowFunction_Bound& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_kind();
  switch (from.kind_case()) {
    case kPreceding: {
      _internal_mutable_preceding()->::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding());
      break;
    }
    case kFollowing: {
      _internal_mutable_following()->::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following());
      break;
    }
    case kCurrentRow: {
      _internal_mutable_current_row()->::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row());
      break;
    }
    case kUnbounded: {
      _internal_mutable_unbounded()->::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded());
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound)
}

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

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

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

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

void Expression_WindowFunction_Bound::clear_kind() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.WindowFunction.Bound)
  switch (kind_case()) {
    case kPreceding: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.preceding_;
      }
      break;
    }
    case kFollowing: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.following_;
      }
      break;
    }
    case kCurrentRow: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.current_row_;
      }
      break;
    }
    case kUnbounded: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.unbounded_;
      }
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = KIND_NOT_SET;
}


void Expression_WindowFunction_Bound::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound)
  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* Expression_WindowFunction_Bound::_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.Expression.WindowFunction.Bound.Preceding preceding = 1 [json_name = "preceding"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_preceding(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.WindowFunction.Bound.Following following = 2 [json_name = "following"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_following(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3 [json_name = "currentRow"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_current_row(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4 [json_name = "unbounded"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_unbounded(), 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* Expression_WindowFunction_Bound::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1 [json_name = "preceding"];
  if (_internal_has_preceding()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::preceding(this), target, stream);
  }

  // .substrait.Expression.WindowFunction.Bound.Following following = 2 [json_name = "following"];
  if (_internal_has_following()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::following(this), target, stream);
  }

  // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3 [json_name = "currentRow"];
  if (_internal_has_current_row()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::current_row(this), target, stream);
  }

  // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4 [json_name = "unbounded"];
  if (_internal_has_unbounded()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::unbounded(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.Expression.WindowFunction.Bound)
  return target;
}

size_t Expression_WindowFunction_Bound::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound)
  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.Expression.WindowFunction.Bound.Preceding preceding = 1 [json_name = "preceding"];
    case kPreceding: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.preceding_);
      break;
    }
    // .substrait.Expression.WindowFunction.Bound.Following following = 2 [json_name = "following"];
    case kFollowing: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.following_);
      break;
    }
    // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3 [json_name = "currentRow"];
    case kCurrentRow: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.current_row_);
      break;
    }
    // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4 [json_name = "unbounded"];
    case kUnbounded: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.unbounded_);
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  switch (from.kind_case()) {
    case kPreceding: {
      _internal_mutable_preceding()->::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding());
      break;
    }
    case kFollowing: {
      _internal_mutable_following()->::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following());
      break;
    }
    case kCurrentRow: {
      _internal_mutable_current_row()->::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row());
      break;
    }
    case kUnbounded: {
      _internal_mutable_unbounded()->::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded());
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_WindowFunction_Bound::InternalSwap(Expression_WindowFunction_Bound* 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 Expression_WindowFunction_Bound::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[43]);
}

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

class Expression_WindowFunction::_Internal {
 public:
  static const ::substrait::Expression_WindowFunction_Bound& upper_bound(const Expression_WindowFunction* msg);
  static const ::substrait::Expression_WindowFunction_Bound& lower_bound(const Expression_WindowFunction* msg);
  static const ::substrait::Type& output_type(const Expression_WindowFunction* msg);
};

const ::substrait::Expression_WindowFunction_Bound&
Expression_WindowFunction::_Internal::upper_bound(const Expression_WindowFunction* msg) {
  return *msg->upper_bound_;
}
const ::substrait::Expression_WindowFunction_Bound&
Expression_WindowFunction::_Internal::lower_bound(const Expression_WindowFunction* msg) {
  return *msg->lower_bound_;
}
const ::substrait::Type&
Expression_WindowFunction::_Internal::output_type(const Expression_WindowFunction* msg) {
  return *msg->output_type_;
}
void Expression_WindowFunction::clear_output_type() {
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
}
Expression_WindowFunction::Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  partitions_(arena),
  sorts_(arena),
  args_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction)
}
Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      partitions_(from.partitions_),
      sorts_(from.sorts_),
      args_(from.args_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_upper_bound()) {
    upper_bound_ = new ::substrait::Expression_WindowFunction_Bound(*from.upper_bound_);
  } else {
    upper_bound_ = nullptr;
  }
  if (from._internal_has_lower_bound()) {
    lower_bound_ = new ::substrait::Expression_WindowFunction_Bound(*from.lower_bound_);
  } else {
    lower_bound_ = nullptr;
  }
  if (from._internal_has_output_type()) {
    output_type_ = new ::substrait::Type(*from.output_type_);
  } else {
    output_type_ = nullptr;
  }
  ::memcpy(&function_reference_, &from.function_reference_,
    static_cast<size_t>(reinterpret_cast<char*>(&phase_) -
    reinterpret_cast<char*>(&function_reference_)) + sizeof(phase_));
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction)
}

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

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

inline void Expression_WindowFunction::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete upper_bound_;
  if (this != internal_default_instance()) delete lower_bound_;
  if (this != internal_default_instance()) delete output_type_;
}

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

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

  partitions_.Clear();
  sorts_.Clear();
  args_.Clear();
  if (GetArenaForAllocation() == nullptr && upper_bound_ != nullptr) {
    delete upper_bound_;
  }
  upper_bound_ = nullptr;
  if (GetArenaForAllocation() == nullptr && lower_bound_ != nullptr) {
    delete lower_bound_;
  }
  lower_bound_ = nullptr;
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
  ::memset(&function_reference_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&phase_) -
      reinterpret_cast<char*>(&function_reference_)) + sizeof(phase_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_WindowFunction::_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) {
      // uint32 function_reference = 1 [json_name = "functionReference"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.Expression partitions = 2 [json_name = "partitions"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_partitions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.SortField sorts = 3 [json_name = "sorts"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_sorts(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.WindowFunction.Bound upper_bound = 4 [json_name = "upperBound"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_upper_bound(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.WindowFunction.Bound lower_bound = 5 [json_name = "lowerBound"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_lower_bound(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.AggregationPhase phase = 6 [json_name = "phase"];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_phase(static_cast<::substrait::AggregationPhase>(val));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type output_type = 7 [json_name = "outputType"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.Expression args = 8 [json_name = "args"];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_args(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(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* Expression_WindowFunction::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 function_reference = 1 [json_name = "functionReference"];
  if (this->_internal_function_reference() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target);
  }

  // repeated .substrait.Expression partitions = 2 [json_name = "partitions"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_partitions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_partitions(i), target, stream);
  }

  // repeated .substrait.SortField sorts = 3 [json_name = "sorts"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_sorts_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_sorts(i), target, stream);
  }

  // .substrait.Expression.WindowFunction.Bound upper_bound = 4 [json_name = "upperBound"];
  if (this->_internal_has_upper_bound()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::upper_bound(this), target, stream);
  }

  // .substrait.Expression.WindowFunction.Bound lower_bound = 5 [json_name = "lowerBound"];
  if (this->_internal_has_lower_bound()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::lower_bound(this), target, stream);
  }

  // .substrait.AggregationPhase phase = 6 [json_name = "phase"];
  if (this->_internal_phase() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      6, this->_internal_phase(), target);
  }

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

  // repeated .substrait.Expression args = 8 [json_name = "args"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_args_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(8, this->_internal_args(i), 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.Expression.WindowFunction)
  return target;
}

size_t Expression_WindowFunction::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction)
  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.Expression partitions = 2 [json_name = "partitions"];
  total_size += 1UL * this->_internal_partitions_size();
  for (const auto& msg : this->partitions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .substrait.SortField sorts = 3 [json_name = "sorts"];
  total_size += 1UL * this->_internal_sorts_size();
  for (const auto& msg : this->sorts_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .substrait.Expression args = 8 [json_name = "args"];
  total_size += 1UL * this->_internal_args_size();
  for (const auto& msg : this->args_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.Expression.WindowFunction.Bound upper_bound = 4 [json_name = "upperBound"];
  if (this->_internal_has_upper_bound()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *upper_bound_);
  }

  // .substrait.Expression.WindowFunction.Bound lower_bound = 5 [json_name = "lowerBound"];
  if (this->_internal_has_lower_bound()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *lower_bound_);
  }

  // .substrait.Type output_type = 7 [json_name = "outputType"];
  if (this->_internal_has_output_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *output_type_);
  }

  // uint32 function_reference = 1 [json_name = "functionReference"];
  if (this->_internal_function_reference() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference());
  }

  // .substrait.AggregationPhase phase = 6 [json_name = "phase"];
  if (this->_internal_phase() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  partitions_.MergeFrom(from.partitions_);
  sorts_.MergeFrom(from.sorts_);
  args_.MergeFrom(from.args_);
  if (from._internal_has_upper_bound()) {
    _internal_mutable_upper_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_upper_bound());
  }
  if (from._internal_has_lower_bound()) {
    _internal_mutable_lower_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_lower_bound());
  }
  if (from._internal_has_output_type()) {
    _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type());
  }
  if (from._internal_function_reference() != 0) {
    _internal_set_function_reference(from._internal_function_reference());
  }
  if (from._internal_phase() != 0) {
    _internal_set_phase(from._internal_phase());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_WindowFunction::InternalSwap(Expression_WindowFunction* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  partitions_.InternalSwap(&other->partitions_);
  sorts_.InternalSwap(&other->sorts_);
  args_.InternalSwap(&other->args_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, phase_)
      + sizeof(Expression_WindowFunction::phase_)
      - PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, upper_bound_)>(
          reinterpret_cast<char*>(&upper_bound_),
          reinterpret_cast<char*>(&other->upper_bound_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[44]);
}

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

class Expression_IfThen_IfClause::_Internal {
 public:
  static const ::substrait::Expression& if_(const Expression_IfThen_IfClause* msg);
  static const ::substrait::Expression& then(const Expression_IfThen_IfClause* msg);
};

const ::substrait::Expression&
Expression_IfThen_IfClause::_Internal::if_(const Expression_IfThen_IfClause* msg) {
  return *msg->if__;
}
const ::substrait::Expression&
Expression_IfThen_IfClause::_Internal::then(const Expression_IfThen_IfClause* msg) {
  return *msg->then_;
}
Expression_IfThen_IfClause::Expression_IfThen_IfClause(::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.Expression.IfThen.IfClause)
}
Expression_IfThen_IfClause::Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_if_()) {
    if__ = new ::substrait::Expression(*from.if__);
  } else {
    if__ = nullptr;
  }
  if (from._internal_has_then()) {
    then_ = new ::substrait::Expression(*from.then_);
  } else {
    then_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen.IfClause)
}

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

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

inline void Expression_IfThen_IfClause::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete if__;
  if (this != internal_default_instance()) delete then_;
}

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

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

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

const char* Expression_IfThen_IfClause::_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.Expression if = 1 [json_name = "if"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression then = 2 [json_name = "then"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_then(), 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* Expression_IfThen_IfClause::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen.IfClause)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // .substrait.Expression then = 2 [json_name = "then"];
  if (this->_internal_has_then()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::then(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.Expression.IfThen.IfClause)
  return target;
}

size_t Expression_IfThen_IfClause::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen.IfClause)
  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.Expression if = 1 [json_name = "if"];
  if (this->_internal_has_if_()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *if__);
  }

  // .substrait.Expression then = 2 [json_name = "then"];
  if (this->_internal_has_then()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *then_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_if_()) {
    _internal_mutable_if_()->::substrait::Expression::MergeFrom(from._internal_if_());
  }
  if (from._internal_has_then()) {
    _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen_IfClause::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[45]);
}

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

class Expression_IfThen::_Internal {
 public:
  static const ::substrait::Expression& else_(const Expression_IfThen* msg);
};

const ::substrait::Expression&
Expression_IfThen::_Internal::else_(const Expression_IfThen* msg) {
  return *msg->else__;
}
Expression_IfThen::Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  ifs_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.IfThen)
}
Expression_IfThen::Expression_IfThen(const Expression_IfThen& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      ifs_(from.ifs_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_else_()) {
    else__ = new ::substrait::Expression(*from.else__);
  } else {
    else__ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen)
}

inline void Expression_IfThen::SharedCtor() {
else__ = nullptr;
}

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

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

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

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

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

const char* Expression_IfThen::_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.Expression.IfThen.IfClause ifs = 1 [json_name = "ifs"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_ifs(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression else = 2 [json_name = "else"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_else_(), 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* Expression_IfThen::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression.IfThen.IfClause ifs = 1 [json_name = "ifs"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_ifs_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_ifs(i), target, stream);
  }

  // .substrait.Expression else = 2 [json_name = "else"];
  if (this->_internal_has_else_()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::else_(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.Expression.IfThen)
  return target;
}

size_t Expression_IfThen::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen)
  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.Expression.IfThen.IfClause ifs = 1 [json_name = "ifs"];
  total_size += 1UL * this->_internal_ifs_size();
  for (const auto& msg : this->ifs_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.Expression else = 2 [json_name = "else"];
  if (this->_internal_has_else_()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *else__);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  ifs_.MergeFrom(from.ifs_);
  if (from._internal_has_else_()) {
    _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_IfThen::InternalSwap(Expression_IfThen* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ifs_.InternalSwap(&other->ifs_);
  swap(else__, other->else__);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[46]);
}

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

class Expression_Cast::_Internal {
 public:
  static const ::substrait::Type& type(const Expression_Cast* msg);
  static const ::substrait::Expression& input(const Expression_Cast* msg);
};

const ::substrait::Type&
Expression_Cast::_Internal::type(const Expression_Cast* msg) {
  return *msg->type_;
}
const ::substrait::Expression&
Expression_Cast::_Internal::input(const Expression_Cast* msg) {
  return *msg->input_;
}
void Expression_Cast::clear_type() {
  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
    delete type_;
  }
  type_ = nullptr;
}
Expression_Cast::Expression_Cast(::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.Expression.Cast)
}
Expression_Cast::Expression_Cast(const Expression_Cast& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_type()) {
    type_ = new ::substrait::Type(*from.type_);
  } else {
    type_ = nullptr;
  }
  if (from._internal_has_input()) {
    input_ = new ::substrait::Expression(*from.input_);
  } else {
    input_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Cast)
}

inline void Expression_Cast::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*>(&input_) -
    reinterpret_cast<char*>(&type_)) + sizeof(input_));
}

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

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

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

void Expression_Cast::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.Cast)
  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;
  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
    delete input_;
  }
  input_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Cast::_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 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;
      // .substrait.Expression input = 2 [json_name = "input"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_input(), 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* Expression_Cast::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Cast)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Type 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);
  }

  // .substrait.Expression input = 2 [json_name = "input"];
  if (this->_internal_has_input()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::input(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.Expression.Cast)
  return target;
}

size_t Expression_Cast::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Cast)
  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.Type type = 1 [json_name = "type"];
  if (this->_internal_has_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *type_);
  }

  // .substrait.Expression input = 2 [json_name = "input"];
  if (this->_internal_has_input()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *input_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_type()) {
    _internal_mutable_type()->::substrait::Type::MergeFrom(from._internal_type());
  }
  if (from._internal_has_input()) {
    _internal_mutable_input()->::substrait::Expression::MergeFrom(from._internal_input());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Cast::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[47]);
}

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

class Expression_SwitchExpression_IfValue::_Internal {
 public:
  static const ::substrait::Expression_Literal& if_(const Expression_SwitchExpression_IfValue* msg);
  static const ::substrait::Expression& then(const Expression_SwitchExpression_IfValue* msg);
};

const ::substrait::Expression_Literal&
Expression_SwitchExpression_IfValue::_Internal::if_(const Expression_SwitchExpression_IfValue* msg) {
  return *msg->if__;
}
const ::substrait::Expression&
Expression_SwitchExpression_IfValue::_Internal::then(const Expression_SwitchExpression_IfValue* msg) {
  return *msg->then_;
}
Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(::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.Expression.SwitchExpression.IfValue)
}
Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(const Expression_SwitchExpression_IfValue& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_if_()) {
    if__ = new ::substrait::Expression_Literal(*from.if__);
  } else {
    if__ = nullptr;
  }
  if (from._internal_has_then()) {
    then_ = new ::substrait::Expression(*from.then_);
  } else {
    then_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression.IfValue)
}

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

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

inline void Expression_SwitchExpression_IfValue::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete if__;
  if (this != internal_default_instance()) delete then_;
}

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

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

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

const char* Expression_SwitchExpression_IfValue::_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.Expression.Literal if = 1 [json_name = "if"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression then = 2 [json_name = "then"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_then(), 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* Expression_SwitchExpression_IfValue::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression.IfValue)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // .substrait.Expression then = 2 [json_name = "then"];
  if (this->_internal_has_then()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::then(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.Expression.SwitchExpression.IfValue)
  return target;
}

size_t Expression_SwitchExpression_IfValue::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression.IfValue)
  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.Expression.Literal if = 1 [json_name = "if"];
  if (this->_internal_has_if_()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *if__);
  }

  // .substrait.Expression then = 2 [json_name = "then"];
  if (this->_internal_has_then()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *then_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_if_()) {
    _internal_mutable_if_()->::substrait::Expression_Literal::MergeFrom(from._internal_if_());
  }
  if (from._internal_has_then()) {
    _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression_IfValue::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[48]);
}

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

class Expression_SwitchExpression::_Internal {
 public:
  static const ::substrait::Expression& else_(const Expression_SwitchExpression* msg);
};

const ::substrait::Expression&
Expression_SwitchExpression::_Internal::else_(const Expression_SwitchExpression* msg) {
  return *msg->else__;
}
Expression_SwitchExpression::Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  ifs_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.SwitchExpression)
}
Expression_SwitchExpression::Expression_SwitchExpression(const Expression_SwitchExpression& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      ifs_(from.ifs_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_else_()) {
    else__ = new ::substrait::Expression(*from.else__);
  } else {
    else__ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression)
}

inline void Expression_SwitchExpression::SharedCtor() {
else__ = nullptr;
}

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

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

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

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

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

const char* Expression_SwitchExpression::_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.Expression.SwitchExpression.IfValue ifs = 1 [json_name = "ifs"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_ifs(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression else = 2 [json_name = "else"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_else_(), 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* Expression_SwitchExpression::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1 [json_name = "ifs"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_ifs_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_ifs(i), target, stream);
  }

  // .substrait.Expression else = 2 [json_name = "else"];
  if (this->_internal_has_else_()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::else_(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.Expression.SwitchExpression)
  return target;
}

size_t Expression_SwitchExpression::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression)
  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.Expression.SwitchExpression.IfValue ifs = 1 [json_name = "ifs"];
  total_size += 1UL * this->_internal_ifs_size();
  for (const auto& msg : this->ifs_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.Expression else = 2 [json_name = "else"];
  if (this->_internal_has_else_()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *else__);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  ifs_.MergeFrom(from.ifs_);
  if (from._internal_has_else_()) {
    _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_SwitchExpression::InternalSwap(Expression_SwitchExpression* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ifs_.InternalSwap(&other->ifs_);
  swap(else__, other->else__);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[49]);
}

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

class Expression_SingularOrList::_Internal {
 public:
  static const ::substrait::Expression& value(const Expression_SingularOrList* msg);
};

const ::substrait::Expression&
Expression_SingularOrList::_Internal::value(const Expression_SingularOrList* msg) {
  return *msg->value_;
}
Expression_SingularOrList::Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  options_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.SingularOrList)
}
Expression_SingularOrList::Expression_SingularOrList(const Expression_SingularOrList& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      options_(from.options_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_value()) {
    value_ = new ::substrait::Expression(*from.value_);
  } else {
    value_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.SingularOrList)
}

inline void Expression_SingularOrList::SharedCtor() {
value_ = nullptr;
}

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

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

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

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

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

const char* Expression_SingularOrList::_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.Expression value = 1 [json_name = "value"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.Expression options = 2 [json_name = "options"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_options(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Expression_SingularOrList::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SingularOrList)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // repeated .substrait.Expression options = 2 [json_name = "options"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_options_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_options(i), 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.Expression.SingularOrList)
  return target;
}

size_t Expression_SingularOrList::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SingularOrList)
  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.Expression options = 2 [json_name = "options"];
  total_size += 1UL * this->_internal_options_size();
  for (const auto& msg : this->options_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  options_.MergeFrom(from.options_);
  if (from._internal_has_value()) {
    _internal_mutable_value()->::substrait::Expression::MergeFrom(from._internal_value());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_SingularOrList::InternalSwap(Expression_SingularOrList* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  options_.InternalSwap(&other->options_);
  swap(value_, other->value_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_SingularOrList::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[50]);
}

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

class Expression_MultiOrList_Record::_Internal {
 public:
};

Expression_MultiOrList_Record::Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  fields_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList.Record)
}
Expression_MultiOrList_Record::Expression_MultiOrList_Record(const Expression_MultiOrList_Record& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      fields_(from.fields_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList.Record)
}

inline void Expression_MultiOrList_Record::SharedCtor() {
}

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

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

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

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

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

const char* Expression_MultiOrList_Record::_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.Expression fields = 1 [json_name = "fields"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_fields(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_MultiOrList_Record::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList.Record)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression fields = 1 [json_name = "fields"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_fields_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_fields(i), 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.Expression.MultiOrList.Record)
  return target;
}

size_t Expression_MultiOrList_Record::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList.Record)
  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.Expression fields = 1 [json_name = "fields"];
  total_size += 1UL * this->_internal_fields_size();
  for (const auto& msg : this->fields_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  fields_.MergeFrom(from.fields_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_MultiOrList_Record::InternalSwap(Expression_MultiOrList_Record* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  fields_.InternalSwap(&other->fields_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList_Record::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[51]);
}

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

class Expression_MultiOrList::_Internal {
 public:
};

Expression_MultiOrList::Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  value_(arena),
  options_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList)
}
Expression_MultiOrList::Expression_MultiOrList(const Expression_MultiOrList& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      value_(from.value_),
      options_(from.options_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList)
}

inline void Expression_MultiOrList::SharedCtor() {
}

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

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

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

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

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

const char* Expression_MultiOrList::_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.Expression value = 1 [json_name = "value"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_value(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.Expression.MultiOrList.Record options = 2 [json_name = "options"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_options(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Expression_MultiOrList::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // repeated .substrait.Expression.MultiOrList.Record options = 2 [json_name = "options"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_options_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_options(i), 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.Expression.MultiOrList)
  return target;
}

size_t Expression_MultiOrList::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList)
  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.Expression value = 1 [json_name = "value"];
  total_size += 1UL * this->_internal_value_size();
  for (const auto& msg : this->value_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .substrait.Expression.MultiOrList.Record options = 2 [json_name = "options"];
  total_size += 1UL * this->_internal_options_size();
  for (const auto& msg : this->options_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  value_.MergeFrom(from.value_);
  options_.MergeFrom(from.options_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_MultiOrList::InternalSwap(Expression_MultiOrList* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  value_.InternalSwap(&other->value_);
  options_.InternalSwap(&other->options_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[52]);
}

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

class Expression_EmbeddedFunction_PythonPickleFunction::_Internal {
 public:
};

Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  prerequisite_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
}
Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(const Expression_EmbeddedFunction_PythonPickleFunction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      prerequisite_(from.prerequisite_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_function().empty()) {
    function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_function(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
}

inline void Expression_EmbeddedFunction_PythonPickleFunction::SharedCtor() {
function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void Expression_EmbeddedFunction_PythonPickleFunction::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  function_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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

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

  prerequisite_.Clear();
  function_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_EmbeddedFunction_PythonPickleFunction::_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) {
      // bytes function = 1 [json_name = "function"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_function();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated string prerequisite = 2 [json_name = "prerequisite"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_prerequisite();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Expression_EmbeddedFunction_PythonPickleFunction::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bytes function = 1 [json_name = "function"];
  if (!this->_internal_function().empty()) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_function(), target);
  }

  // repeated string prerequisite = 2 [json_name = "prerequisite"];
  for (int i = 0, n = this->_internal_prerequisite_size(); i < n; i++) {
    const auto& s = this->_internal_prerequisite(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite");
    target = stream->WriteString(2, s, 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.Expression.EmbeddedFunction.PythonPickleFunction)
  return target;
}

size_t Expression_EmbeddedFunction_PythonPickleFunction::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
  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 prerequisite = 2 [json_name = "prerequisite"];
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(prerequisite_.size());
  for (int i = 0, n = prerequisite_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      prerequisite_.Get(i));
  }

  // bytes function = 1 [json_name = "function"];
  if (!this->_internal_function().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_function());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  prerequisite_.MergeFrom(from.prerequisite_);
  if (!from._internal_function().empty()) {
    _internal_set_function(from._internal_function());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_PythonPickleFunction::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[53]);
}

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

class Expression_EmbeddedFunction_WebAssemblyFunction::_Internal {
 public:
};

Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  prerequisite_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
}
Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(const Expression_EmbeddedFunction_WebAssemblyFunction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      prerequisite_(from.prerequisite_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_script().empty()) {
    script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_script(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
}

inline void Expression_EmbeddedFunction_WebAssemblyFunction::SharedCtor() {
script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void Expression_EmbeddedFunction_WebAssemblyFunction::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  script_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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

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

  prerequisite_.Clear();
  script_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_EmbeddedFunction_WebAssemblyFunction::_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) {
      // bytes script = 1 [json_name = "script"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_script();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated string prerequisite = 2 [json_name = "prerequisite"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_prerequisite();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bytes script = 1 [json_name = "script"];
  if (!this->_internal_script().empty()) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_script(), target);
  }

  // repeated string prerequisite = 2 [json_name = "prerequisite"];
  for (int i = 0, n = this->_internal_prerequisite_size(); i < n; i++) {
    const auto& s = this->_internal_prerequisite(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite");
    target = stream->WriteString(2, s, 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.Expression.EmbeddedFunction.WebAssemblyFunction)
  return target;
}

size_t Expression_EmbeddedFunction_WebAssemblyFunction::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
  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 prerequisite = 2 [json_name = "prerequisite"];
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(prerequisite_.size());
  for (int i = 0, n = prerequisite_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      prerequisite_.Get(i));
  }

  // bytes script = 1 [json_name = "script"];
  if (!this->_internal_script().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_script());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  prerequisite_.MergeFrom(from.prerequisite_);
  if (!from._internal_script().empty()) {
    _internal_set_script(from._internal_script());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_WebAssemblyFunction::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[54]);
}

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

class Expression_EmbeddedFunction::_Internal {
 public:
  static const ::substrait::Type& output_type(const Expression_EmbeddedFunction* msg);
  static const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function(const Expression_EmbeddedFunction* msg);
  static const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function(const Expression_EmbeddedFunction* msg);
};

const ::substrait::Type&
Expression_EmbeddedFunction::_Internal::output_type(const Expression_EmbeddedFunction* msg) {
  return *msg->output_type_;
}
const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction&
Expression_EmbeddedFunction::_Internal::python_pickle_function(const Expression_EmbeddedFunction* msg) {
  return *msg->kind_.python_pickle_function_;
}
const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction&
Expression_EmbeddedFunction::_Internal::web_assembly_function(const Expression_EmbeddedFunction* msg) {
  return *msg->kind_.web_assembly_function_;
}
void Expression_EmbeddedFunction::clear_output_type() {
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
}
void Expression_EmbeddedFunction::set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (python_pickle_function) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_EmbeddedFunction_PythonPickleFunction>::GetOwningArena(python_pickle_function);
    if (message_arena != submessage_arena) {
      python_pickle_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, python_pickle_function, submessage_arena);
    }
    set_has_python_pickle_function();
    kind_.python_pickle_function_ = python_pickle_function;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.python_pickle_function)
}
void Expression_EmbeddedFunction::set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_kind();
  if (web_assembly_function) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>::GetOwningArena(web_assembly_function);
    if (message_arena != submessage_arena) {
      web_assembly_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, web_assembly_function, submessage_arena);
    }
    set_has_web_assembly_function();
    kind_.web_assembly_function_ = web_assembly_function;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.web_assembly_function)
}
Expression_EmbeddedFunction::Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  arguments_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction)
}
Expression_EmbeddedFunction::Expression_EmbeddedFunction(const Expression_EmbeddedFunction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      arguments_(from.arguments_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_output_type()) {
    output_type_ = new ::substrait::Type(*from.output_type_);
  } else {
    output_type_ = nullptr;
  }
  clear_has_kind();
  switch (from.kind_case()) {
    case kPythonPickleFunction: {
      _internal_mutable_python_pickle_function()->::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function());
      break;
    }
    case kWebAssemblyFunction: {
      _internal_mutable_web_assembly_function()->::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function());
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction)
}

inline void Expression_EmbeddedFunction::SharedCtor() {
output_type_ = nullptr;
clear_has_kind();
}

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

inline void Expression_EmbeddedFunction::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete output_type_;
  if (has_kind()) {
    clear_kind();
  }
}

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

void Expression_EmbeddedFunction::clear_kind() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.EmbeddedFunction)
  switch (kind_case()) {
    case kPythonPickleFunction: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.python_pickle_function_;
      }
      break;
    }
    case kWebAssemblyFunction: {
      if (GetArenaForAllocation() == nullptr) {
        delete kind_.web_assembly_function_;
      }
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = KIND_NOT_SET;
}


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

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

const char* Expression_EmbeddedFunction::_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.Expression arguments = 1 [json_name = "arguments"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_arguments(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type output_type = 2 [json_name = "outputType"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3 [json_name = "pythonPickleFunction"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_python_pickle_function(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4 [json_name = "webAssemblyFunction"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_web_assembly_function(), 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* Expression_EmbeddedFunction::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3 [json_name = "pythonPickleFunction"];
  if (_internal_has_python_pickle_function()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::python_pickle_function(this), target, stream);
  }

  // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4 [json_name = "webAssemblyFunction"];
  if (_internal_has_web_assembly_function()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::web_assembly_function(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.Expression.EmbeddedFunction)
  return target;
}

size_t Expression_EmbeddedFunction::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction)
  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.Expression arguments = 1 [json_name = "arguments"];
  total_size += 1UL * this->_internal_arguments_size();
  for (const auto& msg : this->arguments_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.Type output_type = 2 [json_name = "outputType"];
  if (this->_internal_has_output_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *output_type_);
  }

  switch (kind_case()) {
    // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3 [json_name = "pythonPickleFunction"];
    case kPythonPickleFunction: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.python_pickle_function_);
      break;
    }
    // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4 [json_name = "webAssemblyFunction"];
    case kWebAssemblyFunction: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *kind_.web_assembly_function_);
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  arguments_.MergeFrom(from.arguments_);
  if (from._internal_has_output_type()) {
    _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type());
  }
  switch (from.kind_case()) {
    case kPythonPickleFunction: {
      _internal_mutable_python_pickle_function()->::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function());
      break;
    }
    case kWebAssemblyFunction: {
      _internal_mutable_web_assembly_function()->::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function());
      break;
    }
    case KIND_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[55]);
}

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

class Expression_ReferenceSegment_MapKey::_Internal {
 public:
  static const ::substrait::Expression_Literal& map_key(const Expression_ReferenceSegment_MapKey* msg);
  static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_MapKey* msg);
};

const ::substrait::Expression_Literal&
Expression_ReferenceSegment_MapKey::_Internal::map_key(const Expression_ReferenceSegment_MapKey* msg) {
  return *msg->map_key_;
}
const ::substrait::Expression_ReferenceSegment&
Expression_ReferenceSegment_MapKey::_Internal::child(const Expression_ReferenceSegment_MapKey* msg) {
  return *msg->child_;
}
Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(::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.Expression.ReferenceSegment.MapKey)
}
Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(const Expression_ReferenceSegment_MapKey& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_map_key()) {
    map_key_ = new ::substrait::Expression_Literal(*from.map_key_);
  } else {
    map_key_ = nullptr;
  }
  if (from._internal_has_child()) {
    child_ = new ::substrait::Expression_ReferenceSegment(*from.child_);
  } else {
    child_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.MapKey)
}

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

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

inline void Expression_ReferenceSegment_MapKey::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete map_key_;
  if (this != internal_default_instance()) delete child_;
}

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

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

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

const char* Expression_ReferenceSegment_MapKey::_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.Expression.Literal map_key = 1 [json_name = "mapKey"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.ReferenceSegment child = 2 [json_name = "child"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_child(), 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* Expression_ReferenceSegment_MapKey::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.MapKey)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.Literal map_key = 1 [json_name = "mapKey"];
  if (this->_internal_has_map_key()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::map_key(this), target, stream);
  }

  // .substrait.Expression.ReferenceSegment child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::child(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.Expression.ReferenceSegment.MapKey)
  return target;
}

size_t Expression_ReferenceSegment_MapKey::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.MapKey)
  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.Expression.Literal map_key = 1 [json_name = "mapKey"];
  if (this->_internal_has_map_key()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *map_key_);
  }

  // .substrait.Expression.ReferenceSegment child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *child_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_map_key()) {
    _internal_mutable_map_key()->::substrait::Expression_Literal::MergeFrom(from._internal_map_key());
  }
  if (from._internal_has_child()) {
    _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_MapKey::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[56]);
}

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

class Expression_ReferenceSegment_StructField::_Internal {
 public:
  static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_StructField* msg);
};

const ::substrait::Expression_ReferenceSegment&
Expression_ReferenceSegment_StructField::_Internal::child(const Expression_ReferenceSegment_StructField* msg) {
  return *msg->child_;
}
Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(::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.Expression.ReferenceSegment.StructField)
}
Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(const Expression_ReferenceSegment_StructField& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_child()) {
    child_ = new ::substrait::Expression_ReferenceSegment(*from.child_);
  } else {
    child_ = nullptr;
  }
  field_ = from.field_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.StructField)
}

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

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

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

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

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

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

const char* Expression_ReferenceSegment_StructField::_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) {
      // int32 field = 1 [json_name = "field"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.ReferenceSegment child = 2 [json_name = "child"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_child(), 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* Expression_ReferenceSegment_StructField::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.StructField)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 field = 1 [json_name = "field"];
  if (this->_internal_field() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target);
  }

  // .substrait.Expression.ReferenceSegment child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::child(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.Expression.ReferenceSegment.StructField)
  return target;
}

size_t Expression_ReferenceSegment_StructField::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.StructField)
  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.Expression.ReferenceSegment child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *child_);
  }

  // int32 field = 1 [json_name = "field"];
  if (this->_internal_field() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_child()) {
    _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child());
  }
  if (from._internal_field() != 0) {
    _internal_set_field(from._internal_field());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_StructField::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[57]);
}

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

class Expression_ReferenceSegment_ListElement::_Internal {
 public:
  static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_ListElement* msg);
};

const ::substrait::Expression_ReferenceSegment&
Expression_ReferenceSegment_ListElement::_Internal::child(const Expression_ReferenceSegment_ListElement* msg) {
  return *msg->child_;
}
Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(::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.Expression.ReferenceSegment.ListElement)
}
Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(const Expression_ReferenceSegment_ListElement& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_child()) {
    child_ = new ::substrait::Expression_ReferenceSegment(*from.child_);
  } else {
    child_ = nullptr;
  }
  offset_ = from.offset_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.ListElement)
}

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

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

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

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

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

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

const char* Expression_ReferenceSegment_ListElement::_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) {
      // int32 offset = 1 [json_name = "offset"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.ReferenceSegment child = 2 [json_name = "child"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_child(), 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* Expression_ReferenceSegment_ListElement::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.ListElement)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 offset = 1 [json_name = "offset"];
  if (this->_internal_offset() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_offset(), target);
  }

  // .substrait.Expression.ReferenceSegment child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::child(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.Expression.ReferenceSegment.ListElement)
  return target;
}

size_t Expression_ReferenceSegment_ListElement::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.ListElement)
  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.Expression.ReferenceSegment child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *child_);
  }

  // int32 offset = 1 [json_name = "offset"];
  if (this->_internal_offset() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_offset());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_child()) {
    _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child());
  }
  if (from._internal_offset() != 0) {
    _internal_set_offset(from._internal_offset());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_ListElement::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[58]);
}

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

class Expression_ReferenceSegment::_Internal {
 public:
  static const ::substrait::Expression_ReferenceSegment_MapKey& map_key(const Expression_ReferenceSegment* msg);
  static const ::substrait::Expression_ReferenceSegment_StructField& struct_field(const Expression_ReferenceSegment* msg);
  static const ::substrait::Expression_ReferenceSegment_ListElement& list_element(const Expression_ReferenceSegment* msg);
};

const ::substrait::Expression_ReferenceSegment_MapKey&
Expression_ReferenceSegment::_Internal::map_key(const Expression_ReferenceSegment* msg) {
  return *msg->reference_type_.map_key_;
}
const ::substrait::Expression_ReferenceSegment_StructField&
Expression_ReferenceSegment::_Internal::struct_field(const Expression_ReferenceSegment* msg) {
  return *msg->reference_type_.struct_field_;
}
const ::substrait::Expression_ReferenceSegment_ListElement&
Expression_ReferenceSegment::_Internal::list_element(const Expression_ReferenceSegment* msg) {
  return *msg->reference_type_.list_element_;
}
void Expression_ReferenceSegment::set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reference_type();
  if (map_key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_MapKey>::GetOwningArena(map_key);
    if (message_arena != submessage_arena) {
      map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, map_key, submessage_arena);
    }
    set_has_map_key();
    reference_type_.map_key_ = map_key;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.map_key)
}
void Expression_ReferenceSegment::set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reference_type();
  if (struct_field) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_StructField>::GetOwningArena(struct_field);
    if (message_arena != submessage_arena) {
      struct_field = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, struct_field, submessage_arena);
    }
    set_has_struct_field();
    reference_type_.struct_field_ = struct_field;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.struct_field)
}
void Expression_ReferenceSegment::set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reference_type();
  if (list_element) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_ListElement>::GetOwningArena(list_element);
    if (message_arena != submessage_arena) {
      list_element = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, list_element, submessage_arena);
    }
    set_has_list_element();
    reference_type_.list_element_ = list_element;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.list_element)
}
Expression_ReferenceSegment::Expression_ReferenceSegment(::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.Expression.ReferenceSegment)
}
Expression_ReferenceSegment::Expression_ReferenceSegment(const Expression_ReferenceSegment& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_reference_type();
  switch (from.reference_type_case()) {
    case kMapKey: {
      _internal_mutable_map_key()->::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key());
      break;
    }
    case kStructField: {
      _internal_mutable_struct_field()->::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field());
      break;
    }
    case kListElement: {
      _internal_mutable_list_element()->::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element());
      break;
    }
    case REFERENCE_TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment)
}

inline void Expression_ReferenceSegment::SharedCtor() {
clear_has_reference_type();
}

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

inline void Expression_ReferenceSegment::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reference_type()) {
    clear_reference_type();
  }
}

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

void Expression_ReferenceSegment::clear_reference_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.ReferenceSegment)
  switch (reference_type_case()) {
    case kMapKey: {
      if (GetArenaForAllocation() == nullptr) {
        delete reference_type_.map_key_;
      }
      break;
    }
    case kStructField: {
      if (GetArenaForAllocation() == nullptr) {
        delete reference_type_.struct_field_;
      }
      break;
    }
    case kListElement: {
      if (GetArenaForAllocation() == nullptr) {
        delete reference_type_.list_element_;
      }
      break;
    }
    case REFERENCE_TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REFERENCE_TYPE_NOT_SET;
}


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

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

const char* Expression_ReferenceSegment::_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.Expression.ReferenceSegment.MapKey map_key = 1 [json_name = "mapKey"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.ReferenceSegment.StructField struct_field = 2 [json_name = "structField"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_struct_field(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.ReferenceSegment.ListElement list_element = 3 [json_name = "listElement"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_list_element(), 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* Expression_ReferenceSegment::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.ReferenceSegment.MapKey map_key = 1 [json_name = "mapKey"];
  if (_internal_has_map_key()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::map_key(this), target, stream);
  }

  // .substrait.Expression.ReferenceSegment.StructField struct_field = 2 [json_name = "structField"];
  if (_internal_has_struct_field()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::struct_field(this), target, stream);
  }

  // .substrait.Expression.ReferenceSegment.ListElement list_element = 3 [json_name = "listElement"];
  if (_internal_has_list_element()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::list_element(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.Expression.ReferenceSegment)
  return target;
}

size_t Expression_ReferenceSegment::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment)
  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 (reference_type_case()) {
    // .substrait.Expression.ReferenceSegment.MapKey map_key = 1 [json_name = "mapKey"];
    case kMapKey: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *reference_type_.map_key_);
      break;
    }
    // .substrait.Expression.ReferenceSegment.StructField struct_field = 2 [json_name = "structField"];
    case kStructField: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *reference_type_.struct_field_);
      break;
    }
    // .substrait.Expression.ReferenceSegment.ListElement list_element = 3 [json_name = "listElement"];
    case kListElement: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *reference_type_.list_element_);
      break;
    }
    case REFERENCE_TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  switch (from.reference_type_case()) {
    case kMapKey: {
      _internal_mutable_map_key()->::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key());
      break;
    }
    case kStructField: {
      _internal_mutable_struct_field()->::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field());
      break;
    }
    case kListElement: {
      _internal_mutable_list_element()->::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element());
      break;
    }
    case REFERENCE_TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[59]);
}

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

class Expression_MaskExpression_Select::_Internal {
 public:
  static const ::substrait::Expression_MaskExpression_StructSelect& struct_(const Expression_MaskExpression_Select* msg);
  static const ::substrait::Expression_MaskExpression_ListSelect& list(const Expression_MaskExpression_Select* msg);
  static const ::substrait::Expression_MaskExpression_MapSelect& map(const Expression_MaskExpression_Select* msg);
};

const ::substrait::Expression_MaskExpression_StructSelect&
Expression_MaskExpression_Select::_Internal::struct_(const Expression_MaskExpression_Select* msg) {
  return *msg->type_.struct__;
}
const ::substrait::Expression_MaskExpression_ListSelect&
Expression_MaskExpression_Select::_Internal::list(const Expression_MaskExpression_Select* msg) {
  return *msg->type_.list_;
}
const ::substrait::Expression_MaskExpression_MapSelect&
Expression_MaskExpression_Select::_Internal::map(const Expression_MaskExpression_Select* msg) {
  return *msg->type_.map_;
}
void Expression_MaskExpression_Select::set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (struct_) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_StructSelect>::GetOwningArena(struct_);
    if (message_arena != submessage_arena) {
      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, struct_, submessage_arena);
    }
    set_has_struct_();
    type_.struct__ = struct_;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.struct)
}
void Expression_MaskExpression_Select::set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (list) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect>::GetOwningArena(list);
    if (message_arena != submessage_arena) {
      list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, list, submessage_arena);
    }
    set_has_list();
    type_.list_ = list;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.list)
}
void Expression_MaskExpression_Select::set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (map) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect>::GetOwningArena(map);
    if (message_arena != submessage_arena) {
      map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, map, submessage_arena);
    }
    set_has_map();
    type_.map_ = map;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.map)
}
Expression_MaskExpression_Select::Expression_MaskExpression_Select(::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.Expression.MaskExpression.Select)
}
Expression_MaskExpression_Select::Expression_MaskExpression_Select(const Expression_MaskExpression_Select& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kStruct: {
      _internal_mutable_struct_()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_());
      break;
    }
    case kList: {
      _internal_mutable_list()->::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list());
      break;
    }
    case kMap: {
      _internal_mutable_map()->::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.Select)
}

inline void Expression_MaskExpression_Select::SharedCtor() {
clear_has_type();
}

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

inline void Expression_MaskExpression_Select::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

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

void Expression_MaskExpression_Select::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.Select)
  switch (type_case()) {
    case kStruct: {
      if (GetArenaForAllocation() == nullptr) {
        delete type_.struct__;
      }
      break;
    }
    case kList: {
      if (GetArenaForAllocation() == nullptr) {
        delete type_.list_;
      }
      break;
    }
    case kMap: {
      if (GetArenaForAllocation() == nullptr) {
        delete type_.map_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = TYPE_NOT_SET;
}


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

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

const char* Expression_MaskExpression_Select::_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.Expression.MaskExpression.StructSelect struct = 1 [json_name = "struct"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.MaskExpression.ListSelect list = 2 [json_name = "list"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_list(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.MaskExpression.MapSelect map = 3 [json_name = "map"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_map(), 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* Expression_MaskExpression_Select::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.Select)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // .substrait.Expression.MaskExpression.MapSelect map = 3 [json_name = "map"];
  if (_internal_has_map()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::map(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.Expression.MaskExpression.Select)
  return target;
}

size_t Expression_MaskExpression_Select::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.Select)
  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 (type_case()) {
    // .substrait.Expression.MaskExpression.StructSelect struct = 1 [json_name = "struct"];
    case kStruct: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *type_.struct__);
      break;
    }
    // .substrait.Expression.MaskExpression.ListSelect list = 2 [json_name = "list"];
    case kList: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *type_.list_);
      break;
    }
    // .substrait.Expression.MaskExpression.MapSelect map = 3 [json_name = "map"];
    case kMap: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *type_.map_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  switch (from.type_case()) {
    case kStruct: {
      _internal_mutable_struct_()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_());
      break;
    }
    case kList: {
      _internal_mutable_list()->::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list());
      break;
    }
    case kMap: {
      _internal_mutable_map()->::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_Select::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[60]);
}

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

class Expression_MaskExpression_StructSelect::_Internal {
 public:
};

Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  struct_items_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.StructSelect)
}
Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(const Expression_MaskExpression_StructSelect& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      struct_items_(from.struct_items_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructSelect)
}

inline void Expression_MaskExpression_StructSelect::SharedCtor() {
}

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

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

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

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

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

const char* Expression_MaskExpression_StructSelect::_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.Expression.MaskExpression.StructItem struct_items = 1 [json_name = "structItems"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_struct_items(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_MaskExpression_StructSelect::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructSelect)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1 [json_name = "structItems"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_struct_items_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_struct_items(i), 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.Expression.MaskExpression.StructSelect)
  return target;
}

size_t Expression_MaskExpression_StructSelect::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructSelect)
  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.Expression.MaskExpression.StructItem struct_items = 1 [json_name = "structItems"];
  total_size += 1UL * this->_internal_struct_items_size();
  for (const auto& msg : this->struct_items_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  struct_items_.MergeFrom(from.struct_items_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_MaskExpression_StructSelect::InternalSwap(Expression_MaskExpression_StructSelect* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  struct_items_.InternalSwap(&other->struct_items_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructSelect::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[61]);
}

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

class Expression_MaskExpression_StructItem::_Internal {
 public:
  static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_StructItem* msg);
};

const ::substrait::Expression_MaskExpression_Select&
Expression_MaskExpression_StructItem::_Internal::child(const Expression_MaskExpression_StructItem* msg) {
  return *msg->child_;
}
Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(::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.Expression.MaskExpression.StructItem)
}
Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(const Expression_MaskExpression_StructItem& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_child()) {
    child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_);
  } else {
    child_ = nullptr;
  }
  field_ = from.field_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructItem)
}

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

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

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

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

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

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

const char* Expression_MaskExpression_StructItem::_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) {
      // int32 field = 1 [json_name = "field"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.MaskExpression.Select child = 2 [json_name = "child"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_child(), 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* Expression_MaskExpression_StructItem::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructItem)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 field = 1 [json_name = "field"];
  if (this->_internal_field() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target);
  }

  // .substrait.Expression.MaskExpression.Select child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::child(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.Expression.MaskExpression.StructItem)
  return target;
}

size_t Expression_MaskExpression_StructItem::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructItem)
  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.Expression.MaskExpression.Select child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *child_);
  }

  // int32 field = 1 [json_name = "field"];
  if (this->_internal_field() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_child()) {
    _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child());
  }
  if (from._internal_field() != 0) {
    _internal_set_field(from._internal_field());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructItem::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[62]);
}

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

class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_Internal {
 public:
};

Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::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.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
}
Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  field_ = from.field_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
}

inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedCtor() {
field_ = 0;
}

Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() {
  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

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

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

void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  field_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_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) {
      // int32 field = 1 [json_name = "field"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 field = 1 [json_name = "field"];
  if (this->_internal_field() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), 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.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
  return target;
}

size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
  size_t total_size = 0;

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

  // int32 field = 1 [json_name = "field"];
  if (this->_internal_field() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_field() != 0) {
    _internal_set_field(from._internal_field());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(field_, other->field_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[63]);
}

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

class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_Internal {
 public:
};

Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::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.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
}
Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&start_, &from.start_,
    static_cast<size_t>(reinterpret_cast<char*>(&end_) -
    reinterpret_cast<char*>(&start_)) + sizeof(end_));
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
}

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

Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() {
  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

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

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

void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_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) {
      // int32 start = 1 [json_name = "start"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 end = 2 [json_name = "end"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 start = 1 [json_name = "start"];
  if (this->_internal_start() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_start(), target);
  }

  // int32 end = 2 [json_name = "end"];
  if (this->_internal_end() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end(), 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.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
  return target;
}

size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
  size_t total_size = 0;

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

  // int32 start = 1 [json_name = "start"];
  if (this->_internal_start() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_start());
  }

  // int32 end = 2 [json_name = "end"];
  if (this->_internal_end() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_end());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_start() != 0) {
    _internal_set_start(from._internal_start());
  }
  if (from._internal_end() != 0) {
    _internal_set_end(from._internal_end());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[64]);
}

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

class Expression_MaskExpression_ListSelect_ListSelectItem::_Internal {
 public:
  static const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg);
  static const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg);
};

const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&
Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) {
  return *msg->type_.item_;
}
const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&
Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) {
  return *msg->type_.slice_;
}
void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (item) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>::GetOwningArena(item);
    if (message_arena != submessage_arena) {
      item = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, item, submessage_arena);
    }
    set_has_item();
    type_.item_ = item;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item)
}
void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (slice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>::GetOwningArena(slice);
    if (message_arena != submessage_arena) {
      slice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, slice, submessage_arena);
    }
    set_has_slice();
    type_.slice_ = slice;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice)
}
Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(::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.Expression.MaskExpression.ListSelect.ListSelectItem)
}
Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(const Expression_MaskExpression_ListSelect_ListSelectItem& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kItem: {
      _internal_mutable_item()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item());
      break;
    }
    case kSlice: {
      _internal_mutable_slice()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
}

inline void Expression_MaskExpression_ListSelect_ListSelectItem::SharedCtor() {
clear_has_type();
}

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

inline void Expression_MaskExpression_ListSelect_ListSelectItem::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

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

void Expression_MaskExpression_ListSelect_ListSelectItem::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
  switch (type_case()) {
    case kItem: {
      if (GetArenaForAllocation() == nullptr) {
        delete type_.item_;
      }
      break;
    }
    case kSlice: {
      if (GetArenaForAllocation() == nullptr) {
        delete type_.slice_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = TYPE_NOT_SET;
}


void Expression_MaskExpression_ListSelect_ListSelectItem::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* Expression_MaskExpression_ListSelect_ListSelectItem::_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.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1 [json_name = "item"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_item(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2 [json_name = "slice"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_slice(), 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* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1 [json_name = "item"];
  if (_internal_has_item()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::item(this), target, stream);
  }

  // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2 [json_name = "slice"];
  if (_internal_has_slice()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::slice(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.Expression.MaskExpression.ListSelect.ListSelectItem)
  return target;
}

size_t Expression_MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
  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 (type_case()) {
    // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1 [json_name = "item"];
    case kItem: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *type_.item_);
      break;
    }
    // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2 [json_name = "slice"];
    case kSlice: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *type_.slice_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kItem: {
      _internal_mutable_item()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item());
      break;
    }
    case kSlice: {
      _internal_mutable_slice()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_MaskExpression_ListSelect_ListSelectItem::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[65]);
}

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

class Expression_MaskExpression_ListSelect::_Internal {
 public:
  static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_ListSelect* msg);
};

const ::substrait::Expression_MaskExpression_Select&
Expression_MaskExpression_ListSelect::_Internal::child(const Expression_MaskExpression_ListSelect* msg) {
  return *msg->child_;
}
Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  selection_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect)
}
Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(const Expression_MaskExpression_ListSelect& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      selection_(from.selection_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_child()) {
    child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_);
  } else {
    child_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect)
}

inline void Expression_MaskExpression_ListSelect::SharedCtor() {
child_ = nullptr;
}

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

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

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

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

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

const char* Expression_MaskExpression_ListSelect::_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.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1 [json_name = "selection"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_selection(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.MaskExpression.Select child = 2 [json_name = "child"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_child(), 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* Expression_MaskExpression_ListSelect::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1 [json_name = "selection"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_selection_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_selection(i), target, stream);
  }

  // .substrait.Expression.MaskExpression.Select child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::child(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.Expression.MaskExpression.ListSelect)
  return target;
}

size_t Expression_MaskExpression_ListSelect::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect)
  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.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1 [json_name = "selection"];
  total_size += 1UL * this->_internal_selection_size();
  for (const auto& msg : this->selection_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.Expression.MaskExpression.Select child = 2 [json_name = "child"];
  if (this->_internal_has_child()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *child_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  selection_.MergeFrom(from.selection_);
  if (from._internal_has_child()) {
    _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void Expression_MaskExpression_ListSelect::InternalSwap(Expression_MaskExpression_ListSelect* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  selection_.InternalSwap(&other->selection_);
  swap(child_, other->child_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[66]);
}

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

class Expression_MaskExpression_MapSelect_MapKey::_Internal {
 public:
};

Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(::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.Expression.MaskExpression.MapSelect.MapKey)
}
Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(const Expression_MaskExpression_MapSelect_MapKey& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_map_key().empty()) {
    map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKey)
}

inline void Expression_MaskExpression_MapSelect_MapKey::SharedCtor() {
map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void Expression_MaskExpression_MapSelect_MapKey::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  map_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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

void Expression_MaskExpression_MapSelect_MapKey::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* Expression_MaskExpression_MapSelect_MapKey::_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 map_key = 1 [json_name = "mapKey"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_map_key();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKey.map_key"));
          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* Expression_MaskExpression_MapSelect_MapKey::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string map_key = 1 [json_name = "mapKey"];
  if (!this->_internal_map_key().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_map_key().data(), static_cast<int>(this->_internal_map_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.Expression.MaskExpression.MapSelect.MapKey.map_key");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_map_key(), 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.Expression.MaskExpression.MapSelect.MapKey)
  return target;
}

size_t Expression_MaskExpression_MapSelect_MapKey::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
  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 map_key = 1 [json_name = "mapKey"];
  if (!this->_internal_map_key().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_map_key());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_map_key().empty()) {
    _internal_set_map_key(from._internal_map_key());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_MaskExpression_MapSelect_MapKey::CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void Expression_MaskExpression_MapSelect_MapKey::InternalSwap(Expression_MaskExpression_MapSelect_MapKey* 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(),
      &map_key_, lhs_arena,
      &other->map_key_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKey::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[67]);
}

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

class Expression_MaskExpression_MapSelect_MapKeyExpression::_Internal {
 public:
};

Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(::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.Expression.MaskExpression.MapSelect.MapKeyExpression)
}
Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(const Expression_MaskExpression_MapSelect_MapKeyExpression& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_map_key_expression().empty()) {
    map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
}

inline void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedCtor() {
map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  map_key_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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

void Expression_MaskExpression_MapSelect_MapKeyExpression::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* Expression_MaskExpression_MapSelect_MapKeyExpression::_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 map_key_expression = 1 [json_name = "mapKeyExpression"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_map_key_expression();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression"));
          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* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string map_key_expression = 1 [json_name = "mapKeyExpression"];
  if (!this->_internal_map_key_expression().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_map_key_expression().data(), static_cast<int>(this->_internal_map_key_expression().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_map_key_expression(), 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.Expression.MaskExpression.MapSelect.MapKeyExpression)
  return target;
}

size_t Expression_MaskExpression_MapSelect_MapKeyExpression::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
  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 map_key_expression = 1 [json_name = "mapKeyExpression"];
  if (!this->_internal_map_key_expression().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_map_key_expression());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_map_key_expression().empty()) {
    _internal_set_map_key_expression(from._internal_map_key_expression());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void Expression_MaskExpression_MapSelect_MapKeyExpression::InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* 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(),
      &map_key_expression_, lhs_arena,
      &other->map_key_expression_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKeyExpression::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[68]);
}

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

class Expression_MaskExpression_MapSelect::_Internal {
 public:
  static const ::substrait::Expression_MaskExpression_MapSelect_MapKey& key(const Expression_MaskExpression_MapSelect* msg);
  static const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression(const Expression_MaskExpression_MapSelect* msg);
  static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_MapSelect* msg);
};

const ::substrait::Expression_MaskExpression_MapSelect_MapKey&
Expression_MaskExpression_MapSelect::_Internal::key(const Expression_MaskExpression_MapSelect* msg) {
  return *msg->select_.key_;
}
const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression&
Expression_MaskExpression_MapSelect::_Internal::expression(const Expression_MaskExpression_MapSelect* msg) {
  return *msg->select_.expression_;
}
const ::substrait::Expression_MaskExpression_Select&
Expression_MaskExpression_MapSelect::_Internal::child(const Expression_MaskExpression_MapSelect* msg) {
  return *msg->child_;
}
void Expression_MaskExpression_MapSelect::set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_select();
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect_MapKey>::GetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    set_has_key();
    select_.key_ = key;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.key)
}
void Expression_MaskExpression_MapSelect::set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_select();
  if (expression) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression>::GetOwningArena(expression);
    if (message_arena != submessage_arena) {
      expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expression, submessage_arena);
    }
    set_has_expression();
    select_.expression_ = expression;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.expression)
}
Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(::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.Expression.MaskExpression.MapSelect)
}
Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(const Expression_MaskExpression_MapSelect& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_child()) {
    child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_);
  } else {
    child_ = nullptr;
  }
  clear_has_select();
  switch (from.select_case()) {
    case kKey: {
      _internal_mutable_key()->::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key());
      break;
    }
    case kExpression: {
      _internal_mutable_expression()->::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression());
      break;
    }
    case SELECT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect)
}

inline void Expression_MaskExpression_MapSelect::SharedCtor() {
child_ = nullptr;
clear_has_select();
}

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

inline void Expression_MaskExpression_MapSelect::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete child_;
  if (has_select()) {
    clear_select();
  }
}

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

void Expression_MaskExpression_MapSelect::clear_select() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.MapSelect)
  switch (select_case()) {
    case kKey: {
      if (GetArenaForAllocation() == nullptr) {
        delete select_.key_;
      }
      break;
    }
    case kExpression: {
      if (GetArenaForAllocation() == nullptr) {
        delete select_.expression_;
      }
      break;
    }
    case SELECT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = SELECT_NOT_SET;
}


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

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

const char* Expression_MaskExpression_MapSelect::_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.Expression.MaskExpression.MapSelect.MapKey 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.Expression.MaskExpression.MapSelect.MapKeyExpression 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;
      // .substrait.Expression.MaskExpression.Select child = 3 [json_name = "child"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_child(), 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* Expression_MaskExpression_MapSelect::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // .substrait.Expression.MaskExpression.Select child = 3 [json_name = "child"];
  if (this->_internal_has_child()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::child(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.Expression.MaskExpression.MapSelect)
  return target;
}

size_t Expression_MaskExpression_MapSelect::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect)
  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.Expression.MaskExpression.Select child = 3 [json_name = "child"];
  if (this->_internal_has_child()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *child_);
  }

  switch (select_case()) {
    // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1 [json_name = "key"];
    case kKey: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *select_.key_);
      break;
    }
    // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2 [json_name = "expression"];
    case kExpression: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *select_.expression_);
      break;
    }
    case SELECT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_child()) {
    _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child());
  }
  switch (from.select_case()) {
    case kKey: {
      _internal_mutable_key()->::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key());
      break;
    }
    case kExpression: {
      _internal_mutable_expression()->::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression());
      break;
    }
    case SELECT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[69]);
}

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

class Expression_MaskExpression::_Internal {
 public:
  static const ::substrait::Expression_MaskExpression_StructSelect& select(const Expression_MaskExpression* msg);
};

const ::substrait::Expression_MaskExpression_StructSelect&
Expression_MaskExpression::_Internal::select(const Expression_MaskExpression* msg) {
  return *msg->select_;
}
Expression_MaskExpression::Expression_MaskExpression(::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.Expression.MaskExpression)
}
Expression_MaskExpression::Expression_MaskExpression(const Expression_MaskExpression& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_select()) {
    select_ = new ::substrait::Expression_MaskExpression_StructSelect(*from.select_);
  } else {
    select_ = nullptr;
  }
  maintain_singular_struct_ = from.maintain_singular_struct_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression)
}

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

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

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

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

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

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

const char* Expression_MaskExpression::_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.Expression.MaskExpression.StructSelect select = 1 [json_name = "select"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_select(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool maintain_singular_struct = 2 [json_name = "maintainSingularStruct"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          maintain_singular_struct_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&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* Expression_MaskExpression::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.MaskExpression.StructSelect select = 1 [json_name = "select"];
  if (this->_internal_has_select()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::select(this), target, stream);
  }

  // bool maintain_singular_struct = 2 [json_name = "maintainSingularStruct"];
  if (this->_internal_maintain_singular_struct() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_maintain_singular_struct(), 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.Expression.MaskExpression)
  return target;
}

size_t Expression_MaskExpression::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression)
  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.Expression.MaskExpression.StructSelect select = 1 [json_name = "select"];
  if (this->_internal_has_select()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *select_);
  }

  // bool maintain_singular_struct = 2 [json_name = "maintainSingularStruct"];
  if (this->_internal_maintain_singular_struct() != 0) {
    total_size += 1 + 1;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_select()) {
    _internal_mutable_select()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_select());
  }
  if (from._internal_maintain_singular_struct() != 0) {
    _internal_set_maintain_singular_struct(from._internal_maintain_singular_struct());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[70]);
}

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

class Expression_FieldReference_RootReference::_Internal {
 public:
};

Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.FieldReference.RootReference)
}
Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference.RootReference)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_FieldReference_RootReference::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_FieldReference_RootReference::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference_RootReference::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[71]);
}

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

class Expression_FieldReference_OuterReference::_Internal {
 public:
};

Expression_FieldReference_OuterReference::Expression_FieldReference_OuterReference(::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.Expression.FieldReference.OuterReference)
}
Expression_FieldReference_OuterReference::Expression_FieldReference_OuterReference(const Expression_FieldReference_OuterReference& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  steps_out_ = from.steps_out_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference.OuterReference)
}

inline void Expression_FieldReference_OuterReference::SharedCtor() {
steps_out_ = 0u;
}

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

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

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

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

  steps_out_ = 0u;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_FieldReference_OuterReference::_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) {
      // uint32 steps_out = 1 [json_name = "stepsOut"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          steps_out_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* Expression_FieldReference_OuterReference::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.FieldReference.OuterReference)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 steps_out = 1 [json_name = "stepsOut"];
  if (this->_internal_steps_out() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_steps_out(), 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.Expression.FieldReference.OuterReference)
  return target;
}

size_t Expression_FieldReference_OuterReference::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.FieldReference.OuterReference)
  size_t total_size = 0;

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

  // uint32 steps_out = 1 [json_name = "stepsOut"];
  if (this->_internal_steps_out() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_steps_out());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_steps_out() != 0) {
    _internal_set_steps_out(from._internal_steps_out());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_FieldReference_OuterReference::CopyFrom(const Expression_FieldReference_OuterReference& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.FieldReference.OuterReference)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Expression_FieldReference_OuterReference::IsInitialized() const {
  return true;
}

void Expression_FieldReference_OuterReference::InternalSwap(Expression_FieldReference_OuterReference* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(steps_out_, other->steps_out_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference_OuterReference::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[72]);
}

// ===================================================================

class Expression_FieldReference::_Internal {
 public:
  static const ::substrait::Expression_ReferenceSegment& direct_reference(const Expression_FieldReference* msg);
  static const ::substrait::Expression_MaskExpression& masked_reference(const Expression_FieldReference* msg);
  static const ::substrait::Expression& expression(const Expression_FieldReference* msg);
  static const ::substrait::Expression_FieldReference_RootReference& root_reference(const Expression_FieldReference* msg);
  static const ::substrait::Expression_FieldReference_OuterReference& outer_reference(const Expression_FieldReference* msg);
};

const ::substrait::Expression_ReferenceSegment&
Expression_FieldReference::_Internal::direct_reference(const Expression_FieldReference* msg) {
  return *msg->reference_type_.direct_reference_;
}
const ::substrait::Expression_MaskExpression&
Expression_FieldReference::_Internal::masked_reference(const Expression_FieldReference* msg) {
  return *msg->reference_type_.masked_reference_;
}
const ::substrait::Expression&
Expression_FieldReference::_Internal::expression(const Expression_FieldReference* msg) {
  return *msg->root_type_.expression_;
}
const ::substrait::Expression_FieldReference_RootReference&
Expression_FieldReference::_Internal::root_reference(const Expression_FieldReference* msg) {
  return *msg->root_type_.root_reference_;
}
const ::substrait::Expression_FieldReference_OuterReference&
Expression_FieldReference::_Internal::outer_reference(const Expression_FieldReference* msg) {
  return *msg->root_type_.outer_reference_;
}
void Expression_FieldReference::set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reference_type();
  if (direct_reference) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(direct_reference);
    if (message_arena != submessage_arena) {
      direct_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, direct_reference, submessage_arena);
    }
    set_has_direct_reference();
    reference_type_.direct_reference_ = direct_reference;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.direct_reference)
}
void Expression_FieldReference::set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reference_type();
  if (masked_reference) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression>::GetOwningArena(masked_reference);
    if (message_arena != submessage_arena) {
      masked_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, masked_reference, submessage_arena);
    }
    set_has_masked_reference();
    reference_type_.masked_reference_ = masked_reference;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.masked_reference)
}
void Expression_FieldReference::set_allocated_expression(::substrait::Expression* expression) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_root_type();
  if (expression) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(expression);
    if (message_arena != submessage_arena) {
      expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expression, submessage_arena);
    }
    set_has_expression();
    root_type_.expression_ = expression;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.expression)
}
void Expression_FieldReference::set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_root_type();
  if (root_reference) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_FieldReference_RootReference>::GetOwningArena(root_reference);
    if (message_arena != submessage_arena) {
      root_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, root_reference, submessage_arena);
    }
    set_has_root_reference();
    root_type_.root_reference_ = root_reference;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.root_reference)
}
void Expression_FieldReference::set_allocated_outer_reference(::substrait::Expression_FieldReference_OuterReference* outer_reference) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_root_type();
  if (outer_reference) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_FieldReference_OuterReference>::GetOwningArena(outer_reference);
    if (message_arena != submessage_arena) {
      outer_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, outer_reference, submessage_arena);
    }
    set_has_outer_reference();
    root_type_.outer_reference_ = outer_reference;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.outer_reference)
}
Expression_FieldReference::Expression_FieldReference(::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.Expression.FieldReference)
}
Expression_FieldReference::Expression_FieldReference(const Expression_FieldReference& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_reference_type();
  switch (from.reference_type_case()) {
    case kDirectReference: {
      _internal_mutable_direct_reference()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference());
      break;
    }
    case kMaskedReference: {
      _internal_mutable_masked_reference()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference());
      break;
    }
    case REFERENCE_TYPE_NOT_SET: {
      break;
    }
  }
  clear_has_root_type();
  switch (from.root_type_case()) {
    case kExpression: {
      _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression());
      break;
    }
    case kRootReference: {
      _internal_mutable_root_reference()->::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference());
      break;
    }
    case kOuterReference: {
      _internal_mutable_outer_reference()->::substrait::Expression_FieldReference_OuterReference::MergeFrom(from._internal_outer_reference());
      break;
    }
    case ROOT_TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference)
}

inline void Expression_FieldReference::SharedCtor() {
clear_has_reference_type();
clear_has_root_type();
}

Expression_FieldReference::~Expression_FieldReference() {
  // @@protoc_insertion_point(destructor:substrait.Expression.FieldReference)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Expression_FieldReference::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reference_type()) {
    clear_reference_type();
  }
  if (has_root_type()) {
    clear_root_type();
  }
}

void Expression_FieldReference::ArenaDtor(void* object) {
  Expression_FieldReference* _this = reinterpret_cast< Expression_FieldReference* >(object);
  (void)_this;
}
void Expression_FieldReference::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Expression_FieldReference::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Expression_FieldReference::clear_reference_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference)
  switch (reference_type_case()) {
    case kDirectReference: {
      if (GetArenaForAllocation() == nullptr) {
        delete reference_type_.direct_reference_;
      }
      break;
    }
    case kMaskedReference: {
      if (GetArenaForAllocation() == nullptr) {
        delete reference_type_.masked_reference_;
      }
      break;
    }
    case REFERENCE_TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REFERENCE_TYPE_NOT_SET;
}

void Expression_FieldReference::clear_root_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference)
  switch (root_type_case()) {
    case kExpression: {
      if (GetArenaForAllocation() == nullptr) {
        delete root_type_.expression_;
      }
      break;
    }
    case kRootReference: {
      if (GetArenaForAllocation() == nullptr) {
        delete root_type_.root_reference_;
      }
      break;
    }
    case kOuterReference: {
      if (GetArenaForAllocation() == nullptr) {
        delete root_type_.outer_reference_;
      }
      break;
    }
    case ROOT_TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[1] = ROOT_TYPE_NOT_SET;
}


void Expression_FieldReference::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.FieldReference)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_reference_type();
  clear_root_type();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_FieldReference::_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.Expression.ReferenceSegment direct_reference = 1 [json_name = "directReference"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_direct_reference(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.MaskExpression masked_reference = 2 [json_name = "maskedReference"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_masked_reference(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression expression = 3 [json_name = "expression"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.FieldReference.RootReference root_reference = 4 [json_name = "rootReference"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_root_reference(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.FieldReference.OuterReference outer_reference = 5 [json_name = "outerReference"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_outer_reference(), 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* Expression_FieldReference::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.FieldReference)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.ReferenceSegment direct_reference = 1 [json_name = "directReference"];
  if (_internal_has_direct_reference()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::direct_reference(this), target, stream);
  }

  // .substrait.Expression.MaskExpression masked_reference = 2 [json_name = "maskedReference"];
  if (_internal_has_masked_reference()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::masked_reference(this), target, stream);
  }

  // .substrait.Expression expression = 3 [json_name = "expression"];
  if (_internal_has_expression()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::expression(this), target, stream);
  }

  // .substrait.Expression.FieldReference.RootReference root_reference = 4 [json_name = "rootReference"];
  if (_internal_has_root_reference()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::root_reference(this), target, stream);
  }

  // .substrait.Expression.FieldReference.OuterReference outer_reference = 5 [json_name = "outerReference"];
  if (_internal_has_outer_reference()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::outer_reference(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.Expression.FieldReference)
  return target;
}

size_t Expression_FieldReference::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.FieldReference)
  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 (reference_type_case()) {
    // .substrait.Expression.ReferenceSegment direct_reference = 1 [json_name = "directReference"];
    case kDirectReference: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *reference_type_.direct_reference_);
      break;
    }
    // .substrait.Expression.MaskExpression masked_reference = 2 [json_name = "maskedReference"];
    case kMaskedReference: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *reference_type_.masked_reference_);
      break;
    }
    case REFERENCE_TYPE_NOT_SET: {
      break;
    }
  }
  switch (root_type_case()) {
    // .substrait.Expression expression = 3 [json_name = "expression"];
    case kExpression: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *root_type_.expression_);
      break;
    }
    // .substrait.Expression.FieldReference.RootReference root_reference = 4 [json_name = "rootReference"];
    case kRootReference: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *root_type_.root_reference_);
      break;
    }
    // .substrait.Expression.FieldReference.OuterReference outer_reference = 5 [json_name = "outerReference"];
    case kOuterReference: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *root_type_.outer_reference_);
      break;
    }
    case ROOT_TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_FieldReference::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Expression_FieldReference::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_FieldReference::GetClassData() const { return &_class_data_; }

void Expression_FieldReference::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Expression_FieldReference *>(to)->MergeFrom(
      static_cast<const Expression_FieldReference &>(from));
}


void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.FieldReference)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reference_type_case()) {
    case kDirectReference: {
      _internal_mutable_direct_reference()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference());
      break;
    }
    case kMaskedReference: {
      _internal_mutable_masked_reference()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference());
      break;
    }
    case REFERENCE_TYPE_NOT_SET: {
      break;
    }
  }
  switch (from.root_type_case()) {
    case kExpression: {
      _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression());
      break;
    }
    case kRootReference: {
      _internal_mutable_root_reference()->::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference());
      break;
    }
    case kOuterReference: {
      _internal_mutable_outer_reference()->::substrait::Expression_FieldReference_OuterReference::MergeFrom(from._internal_outer_reference());
      break;
    }
    case ROOT_TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_FieldReference::CopyFrom(const Expression_FieldReference& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.FieldReference)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Expression_FieldReference::IsInitialized() const {
  return true;
}

void Expression_FieldReference::InternalSwap(Expression_FieldReference* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(reference_type_, other->reference_type_);
  swap(root_type_, other->root_type_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_oneof_case_[1], other->_oneof_case_[1]);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[73]);
}

// ===================================================================

class Expression_Subquery_Scalar::_Internal {
 public:
  static const ::substrait::Rel& input(const Expression_Subquery_Scalar* msg);
};

const ::substrait::Rel&
Expression_Subquery_Scalar::_Internal::input(const Expression_Subquery_Scalar* msg) {
  return *msg->input_;
}
Expression_Subquery_Scalar::Expression_Subquery_Scalar(::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.Expression.Subquery.Scalar)
}
Expression_Subquery_Scalar::Expression_Subquery_Scalar(const Expression_Subquery_Scalar& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_input()) {
    input_ = new ::substrait::Rel(*from.input_);
  } else {
    input_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Subquery.Scalar)
}

inline void Expression_Subquery_Scalar::SharedCtor() {
input_ = nullptr;
}

Expression_Subquery_Scalar::~Expression_Subquery_Scalar() {
  // @@protoc_insertion_point(destructor:substrait.Expression.Subquery.Scalar)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Expression_Subquery_Scalar::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete input_;
}

void Expression_Subquery_Scalar::ArenaDtor(void* object) {
  Expression_Subquery_Scalar* _this = reinterpret_cast< Expression_Subquery_Scalar* >(object);
  (void)_this;
}
void Expression_Subquery_Scalar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Expression_Subquery_Scalar::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Expression_Subquery_Scalar::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.Subquery.Scalar)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
    delete input_;
  }
  input_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Subquery_Scalar::_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.Rel input = 1 [json_name = "input"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_input(), 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* Expression_Subquery_Scalar::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Subquery.Scalar)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Rel input = 1 [json_name = "input"];
  if (this->_internal_has_input()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::input(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.Expression.Subquery.Scalar)
  return target;
}

size_t Expression_Subquery_Scalar::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Subquery.Scalar)
  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.Rel input = 1 [json_name = "input"];
  if (this->_internal_has_input()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *input_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Subquery_Scalar::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Expression_Subquery_Scalar::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Subquery_Scalar::GetClassData() const { return &_class_data_; }

void Expression_Subquery_Scalar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Expression_Subquery_Scalar *>(to)->MergeFrom(
      static_cast<const Expression_Subquery_Scalar &>(from));
}


void Expression_Subquery_Scalar::MergeFrom(const Expression_Subquery_Scalar& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Subquery.Scalar)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_input()) {
    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_Subquery_Scalar::CopyFrom(const Expression_Subquery_Scalar& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Subquery.Scalar)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Expression_Subquery_Scalar::IsInitialized() const {
  return true;
}

void Expression_Subquery_Scalar::InternalSwap(Expression_Subquery_Scalar* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(input_, other->input_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Subquery_Scalar::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[74]);
}

// ===================================================================

class Expression_Subquery_InPredicate::_Internal {
 public:
  static const ::substrait::Rel& haystack(const Expression_Subquery_InPredicate* msg);
};

const ::substrait::Rel&
Expression_Subquery_InPredicate::_Internal::haystack(const Expression_Subquery_InPredicate* msg) {
  return *msg->haystack_;
}
Expression_Subquery_InPredicate::Expression_Subquery_InPredicate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  needles_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Subquery.InPredicate)
}
Expression_Subquery_InPredicate::Expression_Subquery_InPredicate(const Expression_Subquery_InPredicate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      needles_(from.needles_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_haystack()) {
    haystack_ = new ::substrait::Rel(*from.haystack_);
  } else {
    haystack_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Subquery.InPredicate)
}

inline void Expression_Subquery_InPredicate::SharedCtor() {
haystack_ = nullptr;
}

Expression_Subquery_InPredicate::~Expression_Subquery_InPredicate() {
  // @@protoc_insertion_point(destructor:substrait.Expression.Subquery.InPredicate)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Expression_Subquery_InPredicate::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete haystack_;
}

void Expression_Subquery_InPredicate::ArenaDtor(void* object) {
  Expression_Subquery_InPredicate* _this = reinterpret_cast< Expression_Subquery_InPredicate* >(object);
  (void)_this;
}
void Expression_Subquery_InPredicate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Expression_Subquery_InPredicate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Expression_Subquery_InPredicate::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.Subquery.InPredicate)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  needles_.Clear();
  if (GetArenaForAllocation() == nullptr && haystack_ != nullptr) {
    delete haystack_;
  }
  haystack_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Subquery_InPredicate::_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.Expression needles = 1 [json_name = "needles"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_needles(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel haystack = 2 [json_name = "haystack"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_haystack(), 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* Expression_Subquery_InPredicate::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Subquery.InPredicate)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.Expression needles = 1 [json_name = "needles"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_needles_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_needles(i), target, stream);
  }

  // .substrait.Rel haystack = 2 [json_name = "haystack"];
  if (this->_internal_has_haystack()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::haystack(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.Expression.Subquery.InPredicate)
  return target;
}

size_t Expression_Subquery_InPredicate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Subquery.InPredicate)
  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.Expression needles = 1 [json_name = "needles"];
  total_size += 1UL * this->_internal_needles_size();
  for (const auto& msg : this->needles_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.Rel haystack = 2 [json_name = "haystack"];
  if (this->_internal_has_haystack()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *haystack_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Subquery_InPredicate::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Expression_Subquery_InPredicate::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Subquery_InPredicate::GetClassData() const { return &_class_data_; }

void Expression_Subquery_InPredicate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Expression_Subquery_InPredicate *>(to)->MergeFrom(
      static_cast<const Expression_Subquery_InPredicate &>(from));
}


void Expression_Subquery_InPredicate::MergeFrom(const Expression_Subquery_InPredicate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Subquery.InPredicate)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  needles_.MergeFrom(from.needles_);
  if (from._internal_has_haystack()) {
    _internal_mutable_haystack()->::substrait::Rel::MergeFrom(from._internal_haystack());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_Subquery_InPredicate::CopyFrom(const Expression_Subquery_InPredicate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Subquery.InPredicate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Expression_Subquery_InPredicate::IsInitialized() const {
  return true;
}

void Expression_Subquery_InPredicate::InternalSwap(Expression_Subquery_InPredicate* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  needles_.InternalSwap(&other->needles_);
  swap(haystack_, other->haystack_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Subquery_InPredicate::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[75]);
}

// ===================================================================

class Expression_Subquery_SetPredicate::_Internal {
 public:
  static const ::substrait::Rel& tuples(const Expression_Subquery_SetPredicate* msg);
};

const ::substrait::Rel&
Expression_Subquery_SetPredicate::_Internal::tuples(const Expression_Subquery_SetPredicate* msg) {
  return *msg->tuples_;
}
Expression_Subquery_SetPredicate::Expression_Subquery_SetPredicate(::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.Expression.Subquery.SetPredicate)
}
Expression_Subquery_SetPredicate::Expression_Subquery_SetPredicate(const Expression_Subquery_SetPredicate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_tuples()) {
    tuples_ = new ::substrait::Rel(*from.tuples_);
  } else {
    tuples_ = nullptr;
  }
  predicate_op_ = from.predicate_op_;
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Subquery.SetPredicate)
}

inline void Expression_Subquery_SetPredicate::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&tuples_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&predicate_op_) -
    reinterpret_cast<char*>(&tuples_)) + sizeof(predicate_op_));
}

Expression_Subquery_SetPredicate::~Expression_Subquery_SetPredicate() {
  // @@protoc_insertion_point(destructor:substrait.Expression.Subquery.SetPredicate)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Expression_Subquery_SetPredicate::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete tuples_;
}

void Expression_Subquery_SetPredicate::ArenaDtor(void* object) {
  Expression_Subquery_SetPredicate* _this = reinterpret_cast< Expression_Subquery_SetPredicate* >(object);
  (void)_this;
}
void Expression_Subquery_SetPredicate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Expression_Subquery_SetPredicate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Expression_Subquery_SetPredicate::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.Subquery.SetPredicate)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && tuples_ != nullptr) {
    delete tuples_;
  }
  tuples_ = nullptr;
  predicate_op_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Subquery_SetPredicate::_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.Expression.Subquery.SetPredicate.PredicateOp predicate_op = 1 [json_name = "predicateOp"];
      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_predicate_op(static_cast<::substrait::Expression_Subquery_SetPredicate_PredicateOp>(val));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel tuples = 2 [json_name = "tuples"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_tuples(), 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* Expression_Subquery_SetPredicate::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Subquery.SetPredicate)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.Subquery.SetPredicate.PredicateOp predicate_op = 1 [json_name = "predicateOp"];
  if (this->_internal_predicate_op() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_predicate_op(), target);
  }

  // .substrait.Rel tuples = 2 [json_name = "tuples"];
  if (this->_internal_has_tuples()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::tuples(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.Expression.Subquery.SetPredicate)
  return target;
}

size_t Expression_Subquery_SetPredicate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Subquery.SetPredicate)
  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.Rel tuples = 2 [json_name = "tuples"];
  if (this->_internal_has_tuples()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *tuples_);
  }

  // .substrait.Expression.Subquery.SetPredicate.PredicateOp predicate_op = 1 [json_name = "predicateOp"];
  if (this->_internal_predicate_op() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_predicate_op());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Subquery_SetPredicate::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Expression_Subquery_SetPredicate::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Subquery_SetPredicate::GetClassData() const { return &_class_data_; }

void Expression_Subquery_SetPredicate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Expression_Subquery_SetPredicate *>(to)->MergeFrom(
      static_cast<const Expression_Subquery_SetPredicate &>(from));
}


void Expression_Subquery_SetPredicate::MergeFrom(const Expression_Subquery_SetPredicate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Subquery.SetPredicate)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_tuples()) {
    _internal_mutable_tuples()->::substrait::Rel::MergeFrom(from._internal_tuples());
  }
  if (from._internal_predicate_op() != 0) {
    _internal_set_predicate_op(from._internal_predicate_op());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_Subquery_SetPredicate::CopyFrom(const Expression_Subquery_SetPredicate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Subquery.SetPredicate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Expression_Subquery_SetPredicate::IsInitialized() const {
  return true;
}

void Expression_Subquery_SetPredicate::InternalSwap(Expression_Subquery_SetPredicate* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Expression_Subquery_SetPredicate, predicate_op_)
      + sizeof(Expression_Subquery_SetPredicate::predicate_op_)
      - PROTOBUF_FIELD_OFFSET(Expression_Subquery_SetPredicate, tuples_)>(
          reinterpret_cast<char*>(&tuples_),
          reinterpret_cast<char*>(&other->tuples_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Subquery_SetPredicate::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[76]);
}

// ===================================================================

class Expression_Subquery_SetComparison::_Internal {
 public:
  static const ::substrait::Expression& left(const Expression_Subquery_SetComparison* msg);
  static const ::substrait::Rel& right(const Expression_Subquery_SetComparison* msg);
};

const ::substrait::Expression&
Expression_Subquery_SetComparison::_Internal::left(const Expression_Subquery_SetComparison* msg) {
  return *msg->left_;
}
const ::substrait::Rel&
Expression_Subquery_SetComparison::_Internal::right(const Expression_Subquery_SetComparison* msg) {
  return *msg->right_;
}
Expression_Subquery_SetComparison::Expression_Subquery_SetComparison(::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.Expression.Subquery.SetComparison)
}
Expression_Subquery_SetComparison::Expression_Subquery_SetComparison(const Expression_Subquery_SetComparison& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_left()) {
    left_ = new ::substrait::Expression(*from.left_);
  } else {
    left_ = nullptr;
  }
  if (from._internal_has_right()) {
    right_ = new ::substrait::Rel(*from.right_);
  } else {
    right_ = nullptr;
  }
  ::memcpy(&reduction_op_, &from.reduction_op_,
    static_cast<size_t>(reinterpret_cast<char*>(&comparison_op_) -
    reinterpret_cast<char*>(&reduction_op_)) + sizeof(comparison_op_));
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Subquery.SetComparison)
}

inline void Expression_Subquery_SetComparison::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&left_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&comparison_op_) -
    reinterpret_cast<char*>(&left_)) + sizeof(comparison_op_));
}

Expression_Subquery_SetComparison::~Expression_Subquery_SetComparison() {
  // @@protoc_insertion_point(destructor:substrait.Expression.Subquery.SetComparison)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Expression_Subquery_SetComparison::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete left_;
  if (this != internal_default_instance()) delete right_;
}

void Expression_Subquery_SetComparison::ArenaDtor(void* object) {
  Expression_Subquery_SetComparison* _this = reinterpret_cast< Expression_Subquery_SetComparison* >(object);
  (void)_this;
}
void Expression_Subquery_SetComparison::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Expression_Subquery_SetComparison::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Expression_Subquery_SetComparison::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.Subquery.SetComparison)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && left_ != nullptr) {
    delete left_;
  }
  left_ = nullptr;
  if (GetArenaForAllocation() == nullptr && right_ != nullptr) {
    delete right_;
  }
  right_ = nullptr;
  ::memset(&reduction_op_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&comparison_op_) -
      reinterpret_cast<char*>(&reduction_op_)) + sizeof(comparison_op_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Subquery_SetComparison::_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.Expression.Subquery.SetComparison.ReductionOp reduction_op = 1 [json_name = "reductionOp"];
      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_reduction_op(static_cast<::substrait::Expression_Subquery_SetComparison_ReductionOp>(val));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Subquery.SetComparison.ComparisonOp comparison_op = 2 [json_name = "comparisonOp"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_comparison_op(static_cast<::substrait::Expression_Subquery_SetComparison_ComparisonOp>(val));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression left = 3 [json_name = "left"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_left(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Rel right = 4 [json_name = "right"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_right(), 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* Expression_Subquery_SetComparison::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Subquery.SetComparison)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.Subquery.SetComparison.ReductionOp reduction_op = 1 [json_name = "reductionOp"];
  if (this->_internal_reduction_op() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_reduction_op(), target);
  }

  // .substrait.Expression.Subquery.SetComparison.ComparisonOp comparison_op = 2 [json_name = "comparisonOp"];
  if (this->_internal_comparison_op() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_comparison_op(), target);
  }

  // .substrait.Expression left = 3 [json_name = "left"];
  if (this->_internal_has_left()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::left(this), target, stream);
  }

  // .substrait.Rel right = 4 [json_name = "right"];
  if (this->_internal_has_right()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::right(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.Expression.Subquery.SetComparison)
  return target;
}

size_t Expression_Subquery_SetComparison::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Subquery.SetComparison)
  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.Expression left = 3 [json_name = "left"];
  if (this->_internal_has_left()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *left_);
  }

  // .substrait.Rel right = 4 [json_name = "right"];
  if (this->_internal_has_right()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *right_);
  }

  // .substrait.Expression.Subquery.SetComparison.ReductionOp reduction_op = 1 [json_name = "reductionOp"];
  if (this->_internal_reduction_op() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_reduction_op());
  }

  // .substrait.Expression.Subquery.SetComparison.ComparisonOp comparison_op = 2 [json_name = "comparisonOp"];
  if (this->_internal_comparison_op() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_comparison_op());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Subquery_SetComparison::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Expression_Subquery_SetComparison::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Subquery_SetComparison::GetClassData() const { return &_class_data_; }

void Expression_Subquery_SetComparison::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Expression_Subquery_SetComparison *>(to)->MergeFrom(
      static_cast<const Expression_Subquery_SetComparison &>(from));
}


void Expression_Subquery_SetComparison::MergeFrom(const Expression_Subquery_SetComparison& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Subquery.SetComparison)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_left()) {
    _internal_mutable_left()->::substrait::Expression::MergeFrom(from._internal_left());
  }
  if (from._internal_has_right()) {
    _internal_mutable_right()->::substrait::Rel::MergeFrom(from._internal_right());
  }
  if (from._internal_reduction_op() != 0) {
    _internal_set_reduction_op(from._internal_reduction_op());
  }
  if (from._internal_comparison_op() != 0) {
    _internal_set_comparison_op(from._internal_comparison_op());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_Subquery_SetComparison::CopyFrom(const Expression_Subquery_SetComparison& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Subquery.SetComparison)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Expression_Subquery_SetComparison::IsInitialized() const {
  return true;
}

void Expression_Subquery_SetComparison::InternalSwap(Expression_Subquery_SetComparison* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Expression_Subquery_SetComparison, comparison_op_)
      + sizeof(Expression_Subquery_SetComparison::comparison_op_)
      - PROTOBUF_FIELD_OFFSET(Expression_Subquery_SetComparison, left_)>(
          reinterpret_cast<char*>(&left_),
          reinterpret_cast<char*>(&other->left_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Subquery_SetComparison::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[77]);
}

// ===================================================================

class Expression_Subquery::_Internal {
 public:
  static const ::substrait::Expression_Subquery_Scalar& scalar(const Expression_Subquery* msg);
  static const ::substrait::Expression_Subquery_InPredicate& in_predicate(const Expression_Subquery* msg);
  static const ::substrait::Expression_Subquery_SetPredicate& set_predicate(const Expression_Subquery* msg);
  static const ::substrait::Expression_Subquery_SetComparison& set_comparison(const Expression_Subquery* msg);
};

const ::substrait::Expression_Subquery_Scalar&
Expression_Subquery::_Internal::scalar(const Expression_Subquery* msg) {
  return *msg->subquery_type_.scalar_;
}
const ::substrait::Expression_Subquery_InPredicate&
Expression_Subquery::_Internal::in_predicate(const Expression_Subquery* msg) {
  return *msg->subquery_type_.in_predicate_;
}
const ::substrait::Expression_Subquery_SetPredicate&
Expression_Subquery::_Internal::set_predicate(const Expression_Subquery* msg) {
  return *msg->subquery_type_.set_predicate_;
}
const ::substrait::Expression_Subquery_SetComparison&
Expression_Subquery::_Internal::set_comparison(const Expression_Subquery* msg) {
  return *msg->subquery_type_.set_comparison_;
}
void Expression_Subquery::set_allocated_scalar(::substrait::Expression_Subquery_Scalar* scalar) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_subquery_type();
  if (scalar) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Subquery_Scalar>::GetOwningArena(scalar);
    if (message_arena != submessage_arena) {
      scalar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scalar, submessage_arena);
    }
    set_has_scalar();
    subquery_type_.scalar_ = scalar;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Subquery.scalar)
}
void Expression_Subquery::set_allocated_in_predicate(::substrait::Expression_Subquery_InPredicate* in_predicate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_subquery_type();
  if (in_predicate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Subquery_InPredicate>::GetOwningArena(in_predicate);
    if (message_arena != submessage_arena) {
      in_predicate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, in_predicate, submessage_arena);
    }
    set_has_in_predicate();
    subquery_type_.in_predicate_ = in_predicate;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Subquery.in_predicate)
}
void Expression_Subquery::set_allocated_set_predicate(::substrait::Expression_Subquery_SetPredicate* set_predicate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_subquery_type();
  if (set_predicate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Subquery_SetPredicate>::GetOwningArena(set_predicate);
    if (message_arena != submessage_arena) {
      set_predicate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_predicate, submessage_arena);
    }
    set_has_set_predicate();
    subquery_type_.set_predicate_ = set_predicate;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Subquery.set_predicate)
}
void Expression_Subquery::set_allocated_set_comparison(::substrait::Expression_Subquery_SetComparison* set_comparison) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_subquery_type();
  if (set_comparison) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Subquery_SetComparison>::GetOwningArena(set_comparison);
    if (message_arena != submessage_arena) {
      set_comparison = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_comparison, submessage_arena);
    }
    set_has_set_comparison();
    subquery_type_.set_comparison_ = set_comparison;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Subquery.set_comparison)
}
Expression_Subquery::Expression_Subquery(::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.Expression.Subquery)
}
Expression_Subquery::Expression_Subquery(const Expression_Subquery& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_subquery_type();
  switch (from.subquery_type_case()) {
    case kScalar: {
      _internal_mutable_scalar()->::substrait::Expression_Subquery_Scalar::MergeFrom(from._internal_scalar());
      break;
    }
    case kInPredicate: {
      _internal_mutable_in_predicate()->::substrait::Expression_Subquery_InPredicate::MergeFrom(from._internal_in_predicate());
      break;
    }
    case kSetPredicate: {
      _internal_mutable_set_predicate()->::substrait::Expression_Subquery_SetPredicate::MergeFrom(from._internal_set_predicate());
      break;
    }
    case kSetComparison: {
      _internal_mutable_set_comparison()->::substrait::Expression_Subquery_SetComparison::MergeFrom(from._internal_set_comparison());
      break;
    }
    case SUBQUERY_TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Subquery)
}

inline void Expression_Subquery::SharedCtor() {
clear_has_subquery_type();
}

Expression_Subquery::~Expression_Subquery() {
  // @@protoc_insertion_point(destructor:substrait.Expression.Subquery)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Expression_Subquery::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_subquery_type()) {
    clear_subquery_type();
  }
}

void Expression_Subquery::ArenaDtor(void* object) {
  Expression_Subquery* _this = reinterpret_cast< Expression_Subquery* >(object);
  (void)_this;
}
void Expression_Subquery::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Expression_Subquery::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Expression_Subquery::clear_subquery_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Subquery)
  switch (subquery_type_case()) {
    case kScalar: {
      if (GetArenaForAllocation() == nullptr) {
        delete subquery_type_.scalar_;
      }
      break;
    }
    case kInPredicate: {
      if (GetArenaForAllocation() == nullptr) {
        delete subquery_type_.in_predicate_;
      }
      break;
    }
    case kSetPredicate: {
      if (GetArenaForAllocation() == nullptr) {
        delete subquery_type_.set_predicate_;
      }
      break;
    }
    case kSetComparison: {
      if (GetArenaForAllocation() == nullptr) {
        delete subquery_type_.set_comparison_;
      }
      break;
    }
    case SUBQUERY_TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = SUBQUERY_TYPE_NOT_SET;
}


void Expression_Subquery::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression.Subquery)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_subquery_type();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression_Subquery::_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.Expression.Subquery.Scalar scalar = 1 [json_name = "scalar"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_scalar(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Subquery.InPredicate in_predicate = 2 [json_name = "inPredicate"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_in_predicate(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Subquery.SetPredicate set_predicate = 3 [json_name = "setPredicate"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_set_predicate(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Subquery.SetComparison set_comparison = 4 [json_name = "setComparison"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_set_comparison(), 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* Expression_Subquery::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Subquery)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.Subquery.Scalar scalar = 1 [json_name = "scalar"];
  if (_internal_has_scalar()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::scalar(this), target, stream);
  }

  // .substrait.Expression.Subquery.InPredicate in_predicate = 2 [json_name = "inPredicate"];
  if (_internal_has_in_predicate()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::in_predicate(this), target, stream);
  }

  // .substrait.Expression.Subquery.SetPredicate set_predicate = 3 [json_name = "setPredicate"];
  if (_internal_has_set_predicate()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::set_predicate(this), target, stream);
  }

  // .substrait.Expression.Subquery.SetComparison set_comparison = 4 [json_name = "setComparison"];
  if (_internal_has_set_comparison()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::set_comparison(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.Expression.Subquery)
  return target;
}

size_t Expression_Subquery::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Subquery)
  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 (subquery_type_case()) {
    // .substrait.Expression.Subquery.Scalar scalar = 1 [json_name = "scalar"];
    case kScalar: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subquery_type_.scalar_);
      break;
    }
    // .substrait.Expression.Subquery.InPredicate in_predicate = 2 [json_name = "inPredicate"];
    case kInPredicate: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subquery_type_.in_predicate_);
      break;
    }
    // .substrait.Expression.Subquery.SetPredicate set_predicate = 3 [json_name = "setPredicate"];
    case kSetPredicate: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subquery_type_.set_predicate_);
      break;
    }
    // .substrait.Expression.Subquery.SetComparison set_comparison = 4 [json_name = "setComparison"];
    case kSetComparison: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subquery_type_.set_comparison_);
      break;
    }
    case SUBQUERY_TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Subquery::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Expression_Subquery::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Subquery::GetClassData() const { return &_class_data_; }

void Expression_Subquery::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Expression_Subquery *>(to)->MergeFrom(
      static_cast<const Expression_Subquery &>(from));
}


void Expression_Subquery::MergeFrom(const Expression_Subquery& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Subquery)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.subquery_type_case()) {
    case kScalar: {
      _internal_mutable_scalar()->::substrait::Expression_Subquery_Scalar::MergeFrom(from._internal_scalar());
      break;
    }
    case kInPredicate: {
      _internal_mutable_in_predicate()->::substrait::Expression_Subquery_InPredicate::MergeFrom(from._internal_in_predicate());
      break;
    }
    case kSetPredicate: {
      _internal_mutable_set_predicate()->::substrait::Expression_Subquery_SetPredicate::MergeFrom(from._internal_set_predicate());
      break;
    }
    case kSetComparison: {
      _internal_mutable_set_comparison()->::substrait::Expression_Subquery_SetComparison::MergeFrom(from._internal_set_comparison());
      break;
    }
    case SUBQUERY_TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression_Subquery::CopyFrom(const Expression_Subquery& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Subquery)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Expression_Subquery::IsInitialized() const {
  return true;
}

void Expression_Subquery::InternalSwap(Expression_Subquery* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(subquery_type_, other->subquery_type_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression_Subquery::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[78]);
}

// ===================================================================

class Expression::_Internal {
 public:
  static const ::substrait::Expression_Literal& literal(const Expression* msg);
  static const ::substrait::Expression_FieldReference& selection(const Expression* msg);
  static const ::substrait::Expression_ScalarFunction& scalar_function(const Expression* msg);
  static const ::substrait::Expression_WindowFunction& window_function(const Expression* msg);
  static const ::substrait::Expression_IfThen& if_then(const Expression* msg);
  static const ::substrait::Expression_SwitchExpression& switch_expression(const Expression* msg);
  static const ::substrait::Expression_SingularOrList& singular_or_list(const Expression* msg);
  static const ::substrait::Expression_MultiOrList& multi_or_list(const Expression* msg);
  static const ::substrait::Expression_Enum& enum_(const Expression* msg);
  static const ::substrait::Expression_Cast& cast(const Expression* msg);
  static const ::substrait::Expression_Subquery& subquery(const Expression* msg);
};

const ::substrait::Expression_Literal&
Expression::_Internal::literal(const Expression* msg) {
  return *msg->rex_type_.literal_;
}
const ::substrait::Expression_FieldReference&
Expression::_Internal::selection(const Expression* msg) {
  return *msg->rex_type_.selection_;
}
const ::substrait::Expression_ScalarFunction&
Expression::_Internal::scalar_function(const Expression* msg) {
  return *msg->rex_type_.scalar_function_;
}
const ::substrait::Expression_WindowFunction&
Expression::_Internal::window_function(const Expression* msg) {
  return *msg->rex_type_.window_function_;
}
const ::substrait::Expression_IfThen&
Expression::_Internal::if_then(const Expression* msg) {
  return *msg->rex_type_.if_then_;
}
const ::substrait::Expression_SwitchExpression&
Expression::_Internal::switch_expression(const Expression* msg) {
  return *msg->rex_type_.switch_expression_;
}
const ::substrait::Expression_SingularOrList&
Expression::_Internal::singular_or_list(const Expression* msg) {
  return *msg->rex_type_.singular_or_list_;
}
const ::substrait::Expression_MultiOrList&
Expression::_Internal::multi_or_list(const Expression* msg) {
  return *msg->rex_type_.multi_or_list_;
}
const ::substrait::Expression_Enum&
Expression::_Internal::enum_(const Expression* msg) {
  return *msg->rex_type_.enum__;
}
const ::substrait::Expression_Cast&
Expression::_Internal::cast(const Expression* msg) {
  return *msg->rex_type_.cast_;
}
const ::substrait::Expression_Subquery&
Expression::_Internal::subquery(const Expression* msg) {
  return *msg->rex_type_.subquery_;
}
void Expression::set_allocated_literal(::substrait::Expression_Literal* literal) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (literal) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(literal);
    if (message_arena != submessage_arena) {
      literal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, literal, submessage_arena);
    }
    set_has_literal();
    rex_type_.literal_ = literal;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.literal)
}
void Expression::set_allocated_selection(::substrait::Expression_FieldReference* selection) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (selection) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_FieldReference>::GetOwningArena(selection);
    if (message_arena != submessage_arena) {
      selection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, selection, submessage_arena);
    }
    set_has_selection();
    rex_type_.selection_ = selection;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.selection)
}
void Expression::set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (scalar_function) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ScalarFunction>::GetOwningArena(scalar_function);
    if (message_arena != submessage_arena) {
      scalar_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scalar_function, submessage_arena);
    }
    set_has_scalar_function();
    rex_type_.scalar_function_ = scalar_function;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.scalar_function)
}
void Expression::set_allocated_window_function(::substrait::Expression_WindowFunction* window_function) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (window_function) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction>::GetOwningArena(window_function);
    if (message_arena != submessage_arena) {
      window_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, window_function, submessage_arena);
    }
    set_has_window_function();
    rex_type_.window_function_ = window_function;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.window_function)
}
void Expression::set_allocated_if_then(::substrait::Expression_IfThen* if_then) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (if_then) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_IfThen>::GetOwningArena(if_then);
    if (message_arena != submessage_arena) {
      if_then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, if_then, submessage_arena);
    }
    set_has_if_then();
    rex_type_.if_then_ = if_then;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.if_then)
}
void Expression::set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (switch_expression) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_SwitchExpression>::GetOwningArena(switch_expression);
    if (message_arena != submessage_arena) {
      switch_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, switch_expression, submessage_arena);
    }
    set_has_switch_expression();
    rex_type_.switch_expression_ = switch_expression;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.switch_expression)
}
void Expression::set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (singular_or_list) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_SingularOrList>::GetOwningArena(singular_or_list);
    if (message_arena != submessage_arena) {
      singular_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, singular_or_list, submessage_arena);
    }
    set_has_singular_or_list();
    rex_type_.singular_or_list_ = singular_or_list;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.singular_or_list)
}
void Expression::set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (multi_or_list) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MultiOrList>::GetOwningArena(multi_or_list);
    if (message_arena != submessage_arena) {
      multi_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, multi_or_list, submessage_arena);
    }
    set_has_multi_or_list();
    rex_type_.multi_or_list_ = multi_or_list;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.multi_or_list)
}
void Expression::set_allocated_enum_(::substrait::Expression_Enum* enum_) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (enum_) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Enum>::GetOwningArena(enum_);
    if (message_arena != submessage_arena) {
      enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, enum_, submessage_arena);
    }
    set_has_enum_();
    rex_type_.enum__ = enum_;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.enum)
}
void Expression::set_allocated_cast(::substrait::Expression_Cast* cast) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (cast) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Cast>::GetOwningArena(cast);
    if (message_arena != submessage_arena) {
      cast = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cast, submessage_arena);
    }
    set_has_cast();
    rex_type_.cast_ = cast;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.cast)
}
void Expression::set_allocated_subquery(::substrait::Expression_Subquery* subquery) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_rex_type();
  if (subquery) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Subquery>::GetOwningArena(subquery);
    if (message_arena != submessage_arena) {
      subquery = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, subquery, submessage_arena);
    }
    set_has_subquery();
    rex_type_.subquery_ = subquery;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.subquery)
}
Expression::Expression(::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.Expression)
}
Expression::Expression(const Expression& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_rex_type();
  switch (from.rex_type_case()) {
    case kLiteral: {
      _internal_mutable_literal()->::substrait::Expression_Literal::MergeFrom(from._internal_literal());
      break;
    }
    case kSelection: {
      _internal_mutable_selection()->::substrait::Expression_FieldReference::MergeFrom(from._internal_selection());
      break;
    }
    case kScalarFunction: {
      _internal_mutable_scalar_function()->::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function());
      break;
    }
    case kWindowFunction: {
      _internal_mutable_window_function()->::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function());
      break;
    }
    case kIfThen: {
      _internal_mutable_if_then()->::substrait::Expression_IfThen::MergeFrom(from._internal_if_then());
      break;
    }
    case kSwitchExpression: {
      _internal_mutable_switch_expression()->::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression());
      break;
    }
    case kSingularOrList: {
      _internal_mutable_singular_or_list()->::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list());
      break;
    }
    case kMultiOrList: {
      _internal_mutable_multi_or_list()->::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list());
      break;
    }
    case kEnum: {
      _internal_mutable_enum_()->::substrait::Expression_Enum::MergeFrom(from._internal_enum_());
      break;
    }
    case kCast: {
      _internal_mutable_cast()->::substrait::Expression_Cast::MergeFrom(from._internal_cast());
      break;
    }
    case kSubquery: {
      _internal_mutable_subquery()->::substrait::Expression_Subquery::MergeFrom(from._internal_subquery());
      break;
    }
    case REX_TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.Expression)
}

inline void Expression::SharedCtor() {
clear_has_rex_type();
}

Expression::~Expression() {
  // @@protoc_insertion_point(destructor:substrait.Expression)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Expression::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_rex_type()) {
    clear_rex_type();
  }
}

void Expression::ArenaDtor(void* object) {
  Expression* _this = reinterpret_cast< Expression* >(object);
  (void)_this;
}
void Expression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Expression::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Expression::clear_rex_type() {
// @@protoc_insertion_point(one_of_clear_start:substrait.Expression)
  switch (rex_type_case()) {
    case kLiteral: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.literal_;
      }
      break;
    }
    case kSelection: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.selection_;
      }
      break;
    }
    case kScalarFunction: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.scalar_function_;
      }
      break;
    }
    case kWindowFunction: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.window_function_;
      }
      break;
    }
    case kIfThen: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.if_then_;
      }
      break;
    }
    case kSwitchExpression: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.switch_expression_;
      }
      break;
    }
    case kSingularOrList: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.singular_or_list_;
      }
      break;
    }
    case kMultiOrList: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.multi_or_list_;
      }
      break;
    }
    case kEnum: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.enum__;
      }
      break;
    }
    case kCast: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.cast_;
      }
      break;
    }
    case kSubquery: {
      if (GetArenaForAllocation() == nullptr) {
        delete rex_type_.subquery_;
      }
      break;
    }
    case REX_TYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REX_TYPE_NOT_SET;
}


void Expression::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.Expression)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_rex_type();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Expression::_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.Expression.Literal literal = 1 [json_name = "literal"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_literal(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.FieldReference selection = 2 [json_name = "selection"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_selection(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.ScalarFunction scalar_function = 3 [json_name = "scalarFunction"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_scalar_function(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.WindowFunction window_function = 5 [json_name = "windowFunction"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_window_function(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.IfThen if_then = 6 [json_name = "ifThen"];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_if_then(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.SwitchExpression switch_expression = 7 [json_name = "switchExpression"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_switch_expression(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.SingularOrList singular_or_list = 8 [json_name = "singularOrList"];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_singular_or_list(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.MultiOrList multi_or_list = 9 [json_name = "multiOrList"];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_multi_or_list(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Enum enum = 10 [json_name = "enum"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Cast cast = 11 [json_name = "cast"];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_cast(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Expression.Subquery subquery = 12 [json_name = "subquery"];
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_subquery(), 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* Expression::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression.Literal literal = 1 [json_name = "literal"];
  if (_internal_has_literal()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::literal(this), target, stream);
  }

  // .substrait.Expression.FieldReference selection = 2 [json_name = "selection"];
  if (_internal_has_selection()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::selection(this), target, stream);
  }

  // .substrait.Expression.ScalarFunction scalar_function = 3 [json_name = "scalarFunction"];
  if (_internal_has_scalar_function()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::scalar_function(this), target, stream);
  }

  // .substrait.Expression.WindowFunction window_function = 5 [json_name = "windowFunction"];
  if (_internal_has_window_function()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::window_function(this), target, stream);
  }

  // .substrait.Expression.IfThen if_then = 6 [json_name = "ifThen"];
  if (_internal_has_if_then()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::if_then(this), target, stream);
  }

  // .substrait.Expression.SwitchExpression switch_expression = 7 [json_name = "switchExpression"];
  if (_internal_has_switch_expression()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::switch_expression(this), target, stream);
  }

  // .substrait.Expression.SingularOrList singular_or_list = 8 [json_name = "singularOrList"];
  if (_internal_has_singular_or_list()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::singular_or_list(this), target, stream);
  }

  // .substrait.Expression.MultiOrList multi_or_list = 9 [json_name = "multiOrList"];
  if (_internal_has_multi_or_list()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        9, _Internal::multi_or_list(this), target, stream);
  }

  // .substrait.Expression.Enum enum = 10 [json_name = "enum"];
  if (_internal_has_enum_()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::enum_(this), target, stream);
  }

  // .substrait.Expression.Cast cast = 11 [json_name = "cast"];
  if (_internal_has_cast()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::cast(this), target, stream);
  }

  // .substrait.Expression.Subquery subquery = 12 [json_name = "subquery"];
  if (_internal_has_subquery()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        12, _Internal::subquery(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.Expression)
  return target;
}

size_t Expression::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.Expression)
  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 (rex_type_case()) {
    // .substrait.Expression.Literal literal = 1 [json_name = "literal"];
    case kLiteral: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.literal_);
      break;
    }
    // .substrait.Expression.FieldReference selection = 2 [json_name = "selection"];
    case kSelection: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.selection_);
      break;
    }
    // .substrait.Expression.ScalarFunction scalar_function = 3 [json_name = "scalarFunction"];
    case kScalarFunction: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.scalar_function_);
      break;
    }
    // .substrait.Expression.WindowFunction window_function = 5 [json_name = "windowFunction"];
    case kWindowFunction: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.window_function_);
      break;
    }
    // .substrait.Expression.IfThen if_then = 6 [json_name = "ifThen"];
    case kIfThen: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.if_then_);
      break;
    }
    // .substrait.Expression.SwitchExpression switch_expression = 7 [json_name = "switchExpression"];
    case kSwitchExpression: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.switch_expression_);
      break;
    }
    // .substrait.Expression.SingularOrList singular_or_list = 8 [json_name = "singularOrList"];
    case kSingularOrList: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.singular_or_list_);
      break;
    }
    // .substrait.Expression.MultiOrList multi_or_list = 9 [json_name = "multiOrList"];
    case kMultiOrList: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.multi_or_list_);
      break;
    }
    // .substrait.Expression.Enum enum = 10 [json_name = "enum"];
    case kEnum: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.enum__);
      break;
    }
    // .substrait.Expression.Cast cast = 11 [json_name = "cast"];
    case kCast: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.cast_);
      break;
    }
    // .substrait.Expression.Subquery subquery = 12 [json_name = "subquery"];
    case kSubquery: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *rex_type_.subquery_);
      break;
    }
    case REX_TYPE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Expression::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression::GetClassData() const { return &_class_data_; }

void Expression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<Expression *>(to)->MergeFrom(
      static_cast<const Expression &>(from));
}


void Expression::MergeFrom(const Expression& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.rex_type_case()) {
    case kLiteral: {
      _internal_mutable_literal()->::substrait::Expression_Literal::MergeFrom(from._internal_literal());
      break;
    }
    case kSelection: {
      _internal_mutable_selection()->::substrait::Expression_FieldReference::MergeFrom(from._internal_selection());
      break;
    }
    case kScalarFunction: {
      _internal_mutable_scalar_function()->::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function());
      break;
    }
    case kWindowFunction: {
      _internal_mutable_window_function()->::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function());
      break;
    }
    case kIfThen: {
      _internal_mutable_if_then()->::substrait::Expression_IfThen::MergeFrom(from._internal_if_then());
      break;
    }
    case kSwitchExpression: {
      _internal_mutable_switch_expression()->::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression());
      break;
    }
    case kSingularOrList: {
      _internal_mutable_singular_or_list()->::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list());
      break;
    }
    case kMultiOrList: {
      _internal_mutable_multi_or_list()->::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list());
      break;
    }
    case kEnum: {
      _internal_mutable_enum_()->::substrait::Expression_Enum::MergeFrom(from._internal_enum_());
      break;
    }
    case kCast: {
      _internal_mutable_cast()->::substrait::Expression_Cast::MergeFrom(from._internal_cast());
      break;
    }
    case kSubquery: {
      _internal_mutable_subquery()->::substrait::Expression_Subquery::MergeFrom(from._internal_subquery());
      break;
    }
    case REX_TYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Expression::CopyFrom(const Expression& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Expression::IsInitialized() const {
  return true;
}

void Expression::InternalSwap(Expression* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(rex_type_, other->rex_type_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata Expression::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[79]);
}

// ===================================================================

class SortField::_Internal {
 public:
  static const ::substrait::Expression& expr(const SortField* msg);
};

const ::substrait::Expression&
SortField::_Internal::expr(const SortField* msg) {
  return *msg->expr_;
}
SortField::SortField(::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.SortField)
}
SortField::SortField(const SortField& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_expr()) {
    expr_ = new ::substrait::Expression(*from.expr_);
  } else {
    expr_ = nullptr;
  }
  clear_has_sort_kind();
  switch (from.sort_kind_case()) {
    case kDirection: {
      _internal_set_direction(from._internal_direction());
      break;
    }
    case kComparisonFunctionReference: {
      _internal_set_comparison_function_reference(from._internal_comparison_function_reference());
      break;
    }
    case SORT_KIND_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.SortField)
}

inline void SortField::SharedCtor() {
expr_ = nullptr;
clear_has_sort_kind();
}

SortField::~SortField() {
  // @@protoc_insertion_point(destructor:substrait.SortField)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void SortField::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete expr_;
  if (has_sort_kind()) {
    clear_sort_kind();
  }
}

void SortField::ArenaDtor(void* object) {
  SortField* _this = reinterpret_cast< SortField* >(object);
  (void)_this;
}
void SortField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SortField::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void SortField::clear_sort_kind() {
// @@protoc_insertion_point(one_of_clear_start:substrait.SortField)
  switch (sort_kind_case()) {
    case kDirection: {
      // No need to clear
      break;
    }
    case kComparisonFunctionReference: {
      // No need to clear
      break;
    }
    case SORT_KIND_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = SORT_KIND_NOT_SET;
}


void SortField::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.SortField)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && expr_ != nullptr) {
    delete expr_;
  }
  expr_ = nullptr;
  clear_sort_kind();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* SortField::_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.Expression expr = 1 [json_name = "expr"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_expr(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.SortField.SortDirection direction = 2 [json_name = "direction"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_direction(static_cast<::substrait::SortField_SortDirection>(val));
        } else
          goto handle_unusual;
        continue;
      // uint32 comparison_function_reference = 3 [json_name = "comparisonFunctionReference"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _internal_set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* SortField::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.SortField)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .substrait.Expression expr = 1 [json_name = "expr"];
  if (this->_internal_has_expr()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::expr(this), target, stream);
  }

  // .substrait.SortField.SortDirection direction = 2 [json_name = "direction"];
  if (_internal_has_direction()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_direction(), target);
  }

  // uint32 comparison_function_reference = 3 [json_name = "comparisonFunctionReference"];
  if (_internal_has_comparison_function_reference()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_comparison_function_reference(), 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.SortField)
  return target;
}

size_t SortField::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.SortField)
  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.Expression expr = 1 [json_name = "expr"];
  if (this->_internal_has_expr()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *expr_);
  }

  switch (sort_kind_case()) {
    // .substrait.SortField.SortDirection direction = 2 [json_name = "direction"];
    case kDirection: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction());
      break;
    }
    // uint32 comparison_function_reference = 3 [json_name = "comparisonFunctionReference"];
    case kComparisonFunctionReference: {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_comparison_function_reference());
      break;
    }
    case SORT_KIND_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SortField::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    SortField::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SortField::GetClassData() const { return &_class_data_; }

void SortField::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<SortField *>(to)->MergeFrom(
      static_cast<const SortField &>(from));
}


void SortField::MergeFrom(const SortField& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SortField)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_expr()) {
    _internal_mutable_expr()->::substrait::Expression::MergeFrom(from._internal_expr());
  }
  switch (from.sort_kind_case()) {
    case kDirection: {
      _internal_set_direction(from._internal_direction());
      break;
    }
    case kComparisonFunctionReference: {
      _internal_set_comparison_function_reference(from._internal_comparison_function_reference());
      break;
    }
    case SORT_KIND_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void SortField::CopyFrom(const SortField& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SortField)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SortField::IsInitialized() const {
  return true;
}

void SortField::InternalSwap(SortField* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(expr_, other->expr_);
  swap(sort_kind_, other->sort_kind_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata SortField::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[80]);
}

// ===================================================================

class AggregateFunction::_Internal {
 public:
  static const ::substrait::Type& output_type(const AggregateFunction* msg);
};

const ::substrait::Type&
AggregateFunction::_Internal::output_type(const AggregateFunction* msg) {
  return *msg->output_type_;
}
void AggregateFunction::clear_output_type() {
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
}
AggregateFunction::AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  args_(arena),
  sorts_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.AggregateFunction)
}
AggregateFunction::AggregateFunction(const AggregateFunction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      args_(from.args_),
      sorts_(from.sorts_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_output_type()) {
    output_type_ = new ::substrait::Type(*from.output_type_);
  } else {
    output_type_ = nullptr;
  }
  ::memcpy(&function_reference_, &from.function_reference_,
    static_cast<size_t>(reinterpret_cast<char*>(&phase_) -
    reinterpret_cast<char*>(&function_reference_)) + sizeof(phase_));
  // @@protoc_insertion_point(copy_constructor:substrait.AggregateFunction)
}

inline void AggregateFunction::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&output_type_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&phase_) -
    reinterpret_cast<char*>(&output_type_)) + sizeof(phase_));
}

AggregateFunction::~AggregateFunction() {
  // @@protoc_insertion_point(destructor:substrait.AggregateFunction)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void AggregateFunction::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete output_type_;
}

void AggregateFunction::ArenaDtor(void* object) {
  AggregateFunction* _this = reinterpret_cast< AggregateFunction* >(object);
  (void)_this;
}
void AggregateFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AggregateFunction::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void AggregateFunction::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.AggregateFunction)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  args_.Clear();
  sorts_.Clear();
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
  ::memset(&function_reference_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&phase_) -
      reinterpret_cast<char*>(&function_reference_)) + sizeof(phase_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* AggregateFunction::_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) {
      // uint32 function_reference = 1 [json_name = "functionReference"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.Expression args = 2 [json_name = "args"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_args(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.SortField sorts = 3 [json_name = "sorts"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_sorts(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.AggregationPhase phase = 4 [json_name = "phase"];
      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_phase(static_cast<::substrait::AggregationPhase>(val));
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type output_type = 5 [json_name = "outputType"];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_output_type(), 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* AggregateFunction::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateFunction)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 function_reference = 1 [json_name = "functionReference"];
  if (this->_internal_function_reference() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target);
  }

  // repeated .substrait.Expression args = 2 [json_name = "args"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_args_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_args(i), target, stream);
  }

  // repeated .substrait.SortField sorts = 3 [json_name = "sorts"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_sorts_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_sorts(i), target, stream);
  }

  // .substrait.AggregationPhase phase = 4 [json_name = "phase"];
  if (this->_internal_phase() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_phase(), target);
  }

  // .substrait.Type output_type = 5 [json_name = "outputType"];
  if (this->_internal_has_output_type()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::output_type(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.AggregateFunction)
  return target;
}

size_t AggregateFunction::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateFunction)
  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.Expression args = 2 [json_name = "args"];
  total_size += 1UL * this->_internal_args_size();
  for (const auto& msg : this->args_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .substrait.SortField sorts = 3 [json_name = "sorts"];
  total_size += 1UL * this->_internal_sorts_size();
  for (const auto& msg : this->sorts_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.Type output_type = 5 [json_name = "outputType"];
  if (this->_internal_has_output_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *output_type_);
  }

  // uint32 function_reference = 1 [json_name = "functionReference"];
  if (this->_internal_function_reference() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference());
  }

  // .substrait.AggregationPhase phase = 4 [json_name = "phase"];
  if (this->_internal_phase() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateFunction::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    AggregateFunction::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateFunction::GetClassData() const { return &_class_data_; }

void AggregateFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<AggregateFunction *>(to)->MergeFrom(
      static_cast<const AggregateFunction &>(from));
}


void AggregateFunction::MergeFrom(const AggregateFunction& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateFunction)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  args_.MergeFrom(from.args_);
  sorts_.MergeFrom(from.sorts_);
  if (from._internal_has_output_type()) {
    _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type());
  }
  if (from._internal_function_reference() != 0) {
    _internal_set_function_reference(from._internal_function_reference());
  }
  if (from._internal_phase() != 0) {
    _internal_set_phase(from._internal_phase());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void AggregateFunction::CopyFrom(const AggregateFunction& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateFunction)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AggregateFunction::IsInitialized() const {
  return true;
}

void AggregateFunction::InternalSwap(AggregateFunction* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  args_.InternalSwap(&other->args_);
  sorts_.InternalSwap(&other->sorts_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(AggregateFunction, phase_)
      + sizeof(AggregateFunction::phase_)
      - PROTOBUF_FIELD_OFFSET(AggregateFunction, output_type_)>(
          reinterpret_cast<char*>(&output_type_),
          reinterpret_cast<char*>(&other->output_type_));
}

::PROTOBUF_NAMESPACE_ID::Metadata AggregateFunction::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2falgebra_2eproto_getter, &descriptor_table_substrait_2falgebra_2eproto_once,
      file_level_metadata_substrait_2falgebra_2eproto[81]);
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace substrait
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Direct* Arena::CreateMaybeMessage< ::substrait::RelCommon_Direct >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::RelCommon_Direct >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Emit* Arena::CreateMaybeMessage< ::substrait::RelCommon_Emit >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::RelCommon_Emit >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint_Stats >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint_Stats >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint_RuntimeConstraint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint_RuntimeConstraint >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::RelCommon* Arena::CreateMaybeMessage< ::substrait::RelCommon >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::RelCommon >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_NamedTable >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ReadRel_NamedTable >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_VirtualTable >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ReadRel_VirtualTable >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_ExtensionTable >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ReadRel_ExtensionTable >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage< ::substrait::ReadRel_LocalFiles_FileOrFiles >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ReadRel_LocalFiles_FileOrFiles >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage< ::substrait::ReadRel_LocalFiles >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ReadRel_LocalFiles >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ReadRel* Arena::CreateMaybeMessage< ::substrait::ReadRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ReadRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ProjectRel* Arena::CreateMaybeMessage< ::substrait::ProjectRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ProjectRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::JoinRel* Arena::CreateMaybeMessage< ::substrait::JoinRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::JoinRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::CrossRel* Arena::CreateMaybeMessage< ::substrait::CrossRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::CrossRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FetchRel* Arena::CreateMaybeMessage< ::substrait::FetchRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FetchRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage< ::substrait::AggregateRel_Grouping >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::AggregateRel_Grouping >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage< ::substrait::AggregateRel_Measure >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::AggregateRel_Measure >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::AggregateRel* Arena::CreateMaybeMessage< ::substrait::AggregateRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::AggregateRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::SortRel* Arena::CreateMaybeMessage< ::substrait::SortRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::SortRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FilterRel* Arena::CreateMaybeMessage< ::substrait::FilterRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FilterRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::SetRel* Arena::CreateMaybeMessage< ::substrait::SetRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::SetRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage< ::substrait::ExtensionSingleRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ExtensionSingleRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage< ::substrait::ExtensionLeafRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ExtensionLeafRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage< ::substrait::ExtensionMultiRel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::ExtensionMultiRel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::RelRoot* Arena::CreateMaybeMessage< ::substrait::RelRoot >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::RelRoot >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Rel* Arena::CreateMaybeMessage< ::substrait::Rel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Rel >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage< ::substrait::Expression_Enum_Empty >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Enum_Empty >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Enum* Arena::CreateMaybeMessage< ::substrait::Expression_Enum >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Enum >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_VarChar >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_VarChar >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Decimal >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Decimal >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Map_KeyValue >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Map_KeyValue >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Map >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Map >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_IntervalYearToMonth >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_IntervalYearToMonth >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_IntervalDayToSecond >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_IntervalDayToSecond >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Struct >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Struct >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_List* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_List >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_List >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal* Arena::CreateMaybeMessage< ::substrait::Expression_Literal >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Literal >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage< ::substrait::Expression_ScalarFunction >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_ScalarFunction >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Preceding >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Preceding >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Following >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Following >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Unbounded >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Unbounded >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage< ::substrait::Expression_IfThen_IfClause >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_IfThen_IfClause >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_IfThen* Arena::CreateMaybeMessage< ::substrait::Expression_IfThen >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_IfThen >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Cast* Arena::CreateMaybeMessage< ::substrait::Expression_Cast >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Cast >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage< ::substrait::Expression_SwitchExpression_IfValue >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_SwitchExpression_IfValue >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage< ::substrait::Expression_SwitchExpression >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_SwitchExpression >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage< ::substrait::Expression_SingularOrList >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_SingularOrList >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage< ::substrait::Expression_MultiOrList_Record >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MultiOrList_Record >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage< ::substrait::Expression_MultiOrList >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MultiOrList >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_MapKey >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_MapKey >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_StructField >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_StructField >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_ListElement >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_ListElement >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_Select >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_Select >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructSelect >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_StructSelect >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructItem >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_StructItem >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage< ::substrait::Expression_FieldReference_RootReference >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_FieldReference_RootReference >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_FieldReference_OuterReference* Arena::CreateMaybeMessage< ::substrait::Expression_FieldReference_OuterReference >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_FieldReference_OuterReference >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_FieldReference* Arena::CreateMaybeMessage< ::substrait::Expression_FieldReference >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_FieldReference >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Subquery_Scalar* Arena::CreateMaybeMessage< ::substrait::Expression_Subquery_Scalar >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Subquery_Scalar >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Subquery_InPredicate* Arena::CreateMaybeMessage< ::substrait::Expression_Subquery_InPredicate >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Subquery_InPredicate >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Subquery_SetPredicate* Arena::CreateMaybeMessage< ::substrait::Expression_Subquery_SetPredicate >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Subquery_SetPredicate >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Subquery_SetComparison* Arena::CreateMaybeMessage< ::substrait::Expression_Subquery_SetComparison >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Subquery_SetComparison >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression_Subquery* Arena::CreateMaybeMessage< ::substrait::Expression_Subquery >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression_Subquery >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::Expression* Arena::CreateMaybeMessage< ::substrait::Expression >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::Expression >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::SortField* Arena::CreateMaybeMessage< ::substrait::SortField >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::SortField >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::AggregateFunction* Arena::CreateMaybeMessage< ::substrait::AggregateFunction >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::AggregateFunction >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
