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

#include "substrait/function.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 FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : min_args_(int64_t{0})
  , max_args_(int64_t{0})
  , consistency_(0)
{}
struct FunctionSignature_FinalArgVariadicDefaultTypeInternal {
  constexpr FunctionSignature_FinalArgVariadicDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_FinalArgVariadicDefaultTypeInternal() {}
  union {
    FunctionSignature_FinalArgVariadic _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_FinalArgVariadicDefaultTypeInternal _FunctionSignature_FinalArgVariadic_default_instance_;
constexpr FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct FunctionSignature_FinalArgNormalDefaultTypeInternal {
  constexpr FunctionSignature_FinalArgNormalDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_FinalArgNormalDefaultTypeInternal() {}
  union {
    FunctionSignature_FinalArgNormal _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_FinalArgNormalDefaultTypeInternal _FunctionSignature_FinalArgNormal_default_instance_;
constexpr FunctionSignature_Scalar::FunctionSignature_Scalar(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : arguments_()
  , name_()
  , implementations_()
  , description_(nullptr)
  , output_type_(nullptr)
  , deterministic_(false)
  , session_dependent_(false)
  , _oneof_case_{}{}
struct FunctionSignature_ScalarDefaultTypeInternal {
  constexpr FunctionSignature_ScalarDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_ScalarDefaultTypeInternal() {}
  union {
    FunctionSignature_Scalar _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ScalarDefaultTypeInternal _FunctionSignature_Scalar_default_instance_;
constexpr FunctionSignature_Aggregate::FunctionSignature_Aggregate(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : arguments_()
  , implementations_()
  , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , description_(nullptr)
  , output_type_(nullptr)
  , intermediate_type_(nullptr)
  , deterministic_(false)
  , session_dependent_(false)
  , ordered_(false)
  , max_set_(uint64_t{0u})
  , _oneof_case_{}{}
struct FunctionSignature_AggregateDefaultTypeInternal {
  constexpr FunctionSignature_AggregateDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_AggregateDefaultTypeInternal() {}
  union {
    FunctionSignature_Aggregate _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_AggregateDefaultTypeInternal _FunctionSignature_Aggregate_default_instance_;
constexpr FunctionSignature_Window::FunctionSignature_Window(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : arguments_()
  , name_()
  , implementations_()
  , description_(nullptr)
  , intermediate_type_(nullptr)
  , output_type_(nullptr)
  , deterministic_(false)
  , session_dependent_(false)
  , ordered_(false)
  , window_type_(0)

  , max_set_(uint64_t{0u})
  , _oneof_case_{}{}
struct FunctionSignature_WindowDefaultTypeInternal {
  constexpr FunctionSignature_WindowDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_WindowDefaultTypeInternal() {}
  union {
    FunctionSignature_Window _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_WindowDefaultTypeInternal _FunctionSignature_Window_default_instance_;
constexpr FunctionSignature_Description::FunctionSignature_Description(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : language_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , body_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct FunctionSignature_DescriptionDefaultTypeInternal {
  constexpr FunctionSignature_DescriptionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_DescriptionDefaultTypeInternal() {}
  union {
    FunctionSignature_Description _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_DescriptionDefaultTypeInternal _FunctionSignature_Description_default_instance_;
constexpr FunctionSignature_Implementation::FunctionSignature_Implementation(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , type_(0)
{}
struct FunctionSignature_ImplementationDefaultTypeInternal {
  constexpr FunctionSignature_ImplementationDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_ImplementationDefaultTypeInternal() {}
  union {
    FunctionSignature_Implementation _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ImplementationDefaultTypeInternal _FunctionSignature_Implementation_default_instance_;
constexpr FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : type_(nullptr)
  , constant_(false){}
struct FunctionSignature_Argument_ValueArgumentDefaultTypeInternal {
  constexpr FunctionSignature_Argument_ValueArgumentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_Argument_ValueArgumentDefaultTypeInternal() {}
  union {
    FunctionSignature_Argument_ValueArgument _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_ValueArgumentDefaultTypeInternal _FunctionSignature_Argument_ValueArgument_default_instance_;
constexpr FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : type_(nullptr){}
struct FunctionSignature_Argument_TypeArgumentDefaultTypeInternal {
  constexpr FunctionSignature_Argument_TypeArgumentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_Argument_TypeArgumentDefaultTypeInternal() {}
  union {
    FunctionSignature_Argument_TypeArgument _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_TypeArgumentDefaultTypeInternal _FunctionSignature_Argument_TypeArgument_default_instance_;
constexpr FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : options_()
  , optional_(false){}
struct FunctionSignature_Argument_EnumArgumentDefaultTypeInternal {
  constexpr FunctionSignature_Argument_EnumArgumentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_Argument_EnumArgumentDefaultTypeInternal() {}
  union {
    FunctionSignature_Argument_EnumArgument _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_EnumArgumentDefaultTypeInternal _FunctionSignature_Argument_EnumArgument_default_instance_;
constexpr FunctionSignature_Argument::FunctionSignature_Argument(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , _oneof_case_{}{}
struct FunctionSignature_ArgumentDefaultTypeInternal {
  constexpr FunctionSignature_ArgumentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignature_ArgumentDefaultTypeInternal() {}
  union {
    FunctionSignature_Argument _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ArgumentDefaultTypeInternal _FunctionSignature_Argument_default_instance_;
constexpr FunctionSignature::FunctionSignature(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct FunctionSignatureDefaultTypeInternal {
  constexpr FunctionSignatureDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~FunctionSignatureDefaultTypeInternal() {}
  union {
    FunctionSignature _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignatureDefaultTypeInternal _FunctionSignature_default_instance_;
}  // namespace substrait
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ffunction_2eproto[12];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ffunction_2eproto[3];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ffunction_2eproto = nullptr;

const uint32_t TableStruct_substrait_2ffunction_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, min_args_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, max_args_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, consistency_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgNormal, _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::FunctionSignature_Scalar, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, arguments_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, name_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, description_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, deterministic_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, session_dependent_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, output_type_),
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, implementations_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, final_variable_behavior_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, arguments_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, name_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, description_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, deterministic_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, session_dependent_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, output_type_),
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, ordered_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, max_set_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, intermediate_type_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, implementations_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, final_variable_behavior_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, arguments_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, name_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, description_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, deterministic_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, session_dependent_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, intermediate_type_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, output_type_),
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, ordered_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, max_set_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, window_type_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, implementations_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, final_variable_behavior_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, language_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, body_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, type_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, uri_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, type_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, constant_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_TypeArgument, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_TypeArgument, type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, options_),
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, optional_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, name_),
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, argument_kind_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, -1, -1, sizeof(::substrait::FunctionSignature_FinalArgVariadic)},
  { 9, -1, -1, sizeof(::substrait::FunctionSignature_FinalArgNormal)},
  { 15, -1, -1, sizeof(::substrait::FunctionSignature_Scalar)},
  { 31, -1, -1, sizeof(::substrait::FunctionSignature_Aggregate)},
  { 50, -1, -1, sizeof(::substrait::FunctionSignature_Window)},
  { 70, -1, -1, sizeof(::substrait::FunctionSignature_Description)},
  { 78, -1, -1, sizeof(::substrait::FunctionSignature_Implementation)},
  { 86, -1, -1, sizeof(::substrait::FunctionSignature_Argument_ValueArgument)},
  { 94, -1, -1, sizeof(::substrait::FunctionSignature_Argument_TypeArgument)},
  { 101, -1, -1, sizeof(::substrait::FunctionSignature_Argument_EnumArgument)},
  { 109, -1, -1, sizeof(::substrait::FunctionSignature_Argument)},
  { 120, -1, -1, sizeof(::substrait::FunctionSignature)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_FinalArgVariadic_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_FinalArgNormal_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Scalar_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Aggregate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Window_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Description_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Implementation_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Argument_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_default_instance_),
};

const char descriptor_table_protodef_substrait_2ffunction_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\030substrait/function.proto\022\tsubstrait\032\024s"
  "ubstrait/type.proto\032#substrait/parameter"
  "ized_types.proto\032 substrait/type_express"
  "ions.proto\"\331\031\n\021FunctionSignature\032\274\002\n\020Fin"
  "alArgVariadic\022\031\n\010min_args\030\001 \001(\003R\007minArgs"
  "\022\031\n\010max_args\030\002 \001(\003R\007maxArgs\022d\n\013consisten"
  "cy\030\003 \001(\0162B.substrait.FunctionSignature.F"
  "inalArgVariadic.ParameterConsistencyR\013co"
  "nsistency\"\213\001\n\024ParameterConsistency\022%\n!PA"
  "RAMETER_CONSISTENCY_UNSPECIFIED\020\000\022$\n PAR"
  "AMETER_CONSISTENCY_CONSISTENT\020\001\022&\n\"PARAM"
  "ETER_CONSISTENCY_INCONSISTENT\020\002\032\020\n\016Final"
  "ArgNormal\032\310\004\n\006Scalar\022C\n\targuments\030\002 \003(\0132"
  "%.substrait.FunctionSignature.ArgumentR\t"
  "arguments\022\022\n\004name\030\003 \003(\tR\004name\022J\n\013descrip"
  "tion\030\004 \001(\0132(.substrait.FunctionSignature"
  ".DescriptionR\013description\022$\n\rdeterminist"
  "ic\030\007 \001(\010R\rdeterministic\022+\n\021session_depen"
  "dent\030\010 \001(\010R\020sessionDependent\022@\n\013output_t"
  "ype\030\t \001(\0132\037.substrait.DerivationExpressi"
  "onR\noutputType\022K\n\010variadic\030\n \001(\0132-.subst"
  "rait.FunctionSignature.FinalArgVariadicH"
  "\000R\010variadic\022E\n\006normal\030\013 \001(\0132+.substrait."
  "FunctionSignature.FinalArgNormalH\000R\006norm"
  "al\022U\n\017implementations\030\014 \003(\0132+.substrait."
  "FunctionSignature.ImplementationR\017implem"
  "entationsB\031\n\027final_variable_behavior\032\274\005\n"
  "\tAggregate\022C\n\targuments\030\002 \003(\0132%.substrai"
  "t.FunctionSignature.ArgumentR\targuments\022"
  "\022\n\004name\030\003 \001(\tR\004name\022J\n\013description\030\004 \001(\013"
  "2(.substrait.FunctionSignature.Descripti"
  "onR\013description\022$\n\rdeterministic\030\007 \001(\010R\r"
  "deterministic\022+\n\021session_dependent\030\010 \001(\010"
  "R\020sessionDependent\022@\n\013output_type\030\t \001(\0132"
  "\037.substrait.DerivationExpressionR\noutput"
  "Type\022K\n\010variadic\030\n \001(\0132-.substrait.Funct"
  "ionSignature.FinalArgVariadicH\000R\010variadi"
  "c\022E\n\006normal\030\013 \001(\0132+.substrait.FunctionSi"
  "gnature.FinalArgNormalH\000R\006normal\022\030\n\007orde"
  "red\030\016 \001(\010R\007ordered\022\027\n\007max_set\030\014 \001(\004R\006max"
  "Set\022<\n\021intermediate_type\030\r \001(\0132\017.substra"
  "it.TypeR\020intermediateType\022U\n\017implementat"
  "ions\030\017 \003(\0132+.substrait.FunctionSignature"
  ".ImplementationR\017implementationsB\031\n\027fina"
  "l_variable_behavior\032\373\006\n\006Window\022C\n\targume"
  "nts\030\002 \003(\0132%.substrait.FunctionSignature."
  "ArgumentR\targuments\022\022\n\004name\030\003 \003(\tR\004name\022"
  "J\n\013description\030\004 \001(\0132(.substrait.Functio"
  "nSignature.DescriptionR\013description\022$\n\rd"
  "eterministic\030\007 \001(\010R\rdeterministic\022+\n\021ses"
  "sion_dependent\030\010 \001(\010R\020sessionDependent\022L"
  "\n\021intermediate_type\030\t \001(\0132\037.substrait.De"
  "rivationExpressionR\020intermediateType\022@\n\013"
  "output_type\030\n \001(\0132\037.substrait.Derivation"
  "ExpressionR\noutputType\022K\n\010variadic\030\020 \001(\013"
  "2-.substrait.FunctionSignature.FinalArgV"
  "ariadicH\000R\010variadic\022E\n\006normal\030\021 \001(\0132+.su"
  "bstrait.FunctionSignature.FinalArgNormal"
  "H\000R\006normal\022\030\n\007ordered\030\013 \001(\010R\007ordered\022\027\n\007"
  "max_set\030\014 \001(\004R\006maxSet\022O\n\013window_type\030\016 \001"
  "(\0162..substrait.FunctionSignature.Window."
  "WindowTypeR\nwindowType\022U\n\017implementation"
  "s\030\017 \003(\0132+.substrait.FunctionSignature.Im"
  "plementationR\017implementations\"_\n\nWindowT"
  "ype\022\033\n\027WINDOW_TYPE_UNSPECIFIED\020\000\022\031\n\025WIND"
  "OW_TYPE_STREAMING\020\001\022\031\n\025WINDOW_TYPE_PARTI"
  "TION\020\002B\031\n\027final_variable_behavior\032=\n\013Des"
  "cription\022\032\n\010language\030\001 \001(\tR\010language\022\022\n\004"
  "body\030\002 \001(\tR\004body\032\261\001\n\016Implementation\022D\n\004t"
  "ype\030\001 \001(\01620.substrait.FunctionSignature."
  "Implementation.TypeR\004type\022\020\n\003uri\030\002 \001(\tR\003"
  "uri\"G\n\004Type\022\024\n\020TYPE_UNSPECIFIED\020\000\022\025\n\021TYP"
  "E_WEB_ASSEMBLY\020\001\022\022\n\016TYPE_TRINO_JAR\020\002\032\367\003\n"
  "\010Argument\022\022\n\004name\030\001 \001(\tR\004name\022K\n\005value\030\002"
  " \001(\01323.substrait.FunctionSignature.Argum"
  "ent.ValueArgumentH\000R\005value\022H\n\004type\030\003 \001(\013"
  "22.substrait.FunctionSignature.Argument."
  "TypeArgumentH\000R\004type\022H\n\004enum\030\004 \001(\01322.sub"
  "strait.FunctionSignature.Argument.EnumAr"
  "gumentH\000R\004enum\032]\n\rValueArgument\0220\n\004type\030"
  "\001 \001(\0132\034.substrait.ParameterizedTypeR\004typ"
  "e\022\032\n\010constant\030\002 \001(\010R\010constant\032@\n\014TypeArg"
  "ument\0220\n\004type\030\001 \001(\0132\034.substrait.Paramete"
  "rizedTypeR\004type\032D\n\014EnumArgument\022\030\n\007optio"
  "ns\030\001 \003(\tR\007options\022\032\n\010optional\030\002 \001(\010R\010opt"
  "ionalB\017\n\rargument_kindB+\n\022io.substrait.p"
  "rotoP\001\252\002\022Substrait.Protobufb\006proto3"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2ffunction_2eproto_deps[3] = {
  &::descriptor_table_substrait_2fparameterized_5ftypes_2eproto,
  &::descriptor_table_substrait_2ftype_2eproto,
  &::descriptor_table_substrait_2ftype_5fexpressions_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ffunction_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ffunction_2eproto = {
  false, false, 3475, descriptor_table_protodef_substrait_2ffunction_2eproto, "substrait/function.proto", 
  &descriptor_table_substrait_2ffunction_2eproto_once, descriptor_table_substrait_2ffunction_2eproto_deps, 3, 12,
  schemas, file_default_instances, TableStruct_substrait_2ffunction_2eproto::offsets,
  file_level_metadata_substrait_2ffunction_2eproto, file_level_enum_descriptors_substrait_2ffunction_2eproto, file_level_service_descriptors_substrait_2ffunction_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ffunction_2eproto_getter() {
  return &descriptor_table_substrait_2ffunction_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ffunction_2eproto(&descriptor_table_substrait_2ffunction_2eproto);
namespace substrait {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto);
  return file_level_enum_descriptors_substrait_2ffunction_2eproto[0];
}
bool FunctionSignature_FinalArgVariadic_ParameterConsistency_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 FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_UNSPECIFIED;
constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_CONSISTENT;
constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_INCONSISTENT;
constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MIN;
constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MAX;
constexpr int FunctionSignature_FinalArgVariadic::ParameterConsistency_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto);
  return file_level_enum_descriptors_substrait_2ffunction_2eproto[1];
}
bool FunctionSignature_Window_WindowType_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 FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_UNSPECIFIED;
constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_STREAMING;
constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_PARTITION;
constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MIN;
constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MAX;
constexpr int FunctionSignature_Window::WindowType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto);
  return file_level_enum_descriptors_substrait_2ffunction_2eproto[2];
}
bool FunctionSignature_Implementation_Type_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 FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_UNSPECIFIED;
constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_WEB_ASSEMBLY;
constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_TRINO_JAR;
constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MIN;
constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MAX;
constexpr int FunctionSignature_Implementation::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class FunctionSignature_FinalArgVariadic::_Internal {
 public:
};

FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(::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.FunctionSignature.FinalArgVariadic)
}
FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&min_args_, &from.min_args_,
    static_cast<size_t>(reinterpret_cast<char*>(&consistency_) -
    reinterpret_cast<char*>(&min_args_)) + sizeof(consistency_));
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgVariadic)
}

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

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

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

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

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

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

const char* FunctionSignature_FinalArgVariadic::_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 min_args = 1 [json_name = "minArgs"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          min_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 max_args = 2 [json_name = "maxArgs"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          max_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3 [json_name = "consistency"];
      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_consistency(static_cast<::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // int64 min_args = 1 [json_name = "minArgs"];
  if (this->_internal_min_args() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_min_args(), target);
  }

  // int64 max_args = 2 [json_name = "maxArgs"];
  if (this->_internal_max_args() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_max_args(), target);
  }

  // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3 [json_name = "consistency"];
  if (this->_internal_consistency() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_consistency(), 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.FunctionSignature.FinalArgVariadic)
  return target;
}

size_t FunctionSignature_FinalArgVariadic::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.FinalArgVariadic)
  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 min_args = 1 [json_name = "minArgs"];
  if (this->_internal_min_args() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_min_args());
  }

  // int64 max_args = 2 [json_name = "maxArgs"];
  if (this->_internal_max_args() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_max_args());
  }

  // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3 [json_name = "consistency"];
  if (this->_internal_consistency() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_consistency());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_min_args() != 0) {
    _internal_set_min_args(from._internal_min_args());
  }
  if (from._internal_max_args() != 0) {
    _internal_set_max_args(from._internal_max_args());
  }
  if (from._internal_consistency() != 0) {
    _internal_set_consistency(from._internal_consistency());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgVariadic::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[0]);
}

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

class FunctionSignature_FinalArgNormal::_Internal {
 public:
};

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





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







::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgNormal::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[1]);
}

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

class FunctionSignature_Scalar::_Internal {
 public:
  static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Scalar* msg);
  static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Scalar* msg);
  static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Scalar* msg);
  static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Scalar* msg);
};

const ::substrait::FunctionSignature_Description&
FunctionSignature_Scalar::_Internal::description(const FunctionSignature_Scalar* msg) {
  return *msg->description_;
}
const ::substrait::DerivationExpression&
FunctionSignature_Scalar::_Internal::output_type(const FunctionSignature_Scalar* msg) {
  return *msg->output_type_;
}
const ::substrait::FunctionSignature_FinalArgVariadic&
FunctionSignature_Scalar::_Internal::variadic(const FunctionSignature_Scalar* msg) {
  return *msg->final_variable_behavior_.variadic_;
}
const ::substrait::FunctionSignature_FinalArgNormal&
FunctionSignature_Scalar::_Internal::normal(const FunctionSignature_Scalar* msg) {
  return *msg->final_variable_behavior_.normal_;
}
void FunctionSignature_Scalar::clear_output_type() {
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
}
void FunctionSignature_Scalar::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_final_variable_behavior();
  if (variadic) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic);
    if (message_arena != submessage_arena) {
      variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, variadic, submessage_arena);
    }
    set_has_variadic();
    final_variable_behavior_.variadic_ = variadic;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.variadic)
}
void FunctionSignature_Scalar::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_final_variable_behavior();
  if (normal) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal);
    if (message_arena != submessage_arena) {
      normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, normal, submessage_arena);
    }
    set_has_normal();
    final_variable_behavior_.normal_ = normal;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.normal)
}
FunctionSignature_Scalar::FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  arguments_(arena),
  name_(arena),
  implementations_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Scalar)
}
FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scalar& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      arguments_(from.arguments_),
      name_(from.name_),
      implementations_(from.implementations_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_description()) {
    description_ = new ::substrait::FunctionSignature_Description(*from.description_);
  } else {
    description_ = nullptr;
  }
  if (from._internal_has_output_type()) {
    output_type_ = new ::substrait::DerivationExpression(*from.output_type_);
  } else {
    output_type_ = nullptr;
  }
  ::memcpy(&deterministic_, &from.deterministic_,
    static_cast<size_t>(reinterpret_cast<char*>(&session_dependent_) -
    reinterpret_cast<char*>(&deterministic_)) + sizeof(session_dependent_));
  clear_has_final_variable_behavior();
  switch (from.final_variable_behavior_case()) {
    case kVariadic: {
      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
      break;
    }
    case kNormal: {
      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Scalar)
}

inline void FunctionSignature_Scalar::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&description_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&session_dependent_) -
    reinterpret_cast<char*>(&description_)) + sizeof(session_dependent_));
clear_has_final_variable_behavior();
}

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

inline void FunctionSignature_Scalar::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete description_;
  if (this != internal_default_instance()) delete output_type_;
  if (has_final_variable_behavior()) {
    clear_final_variable_behavior();
  }
}

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

void FunctionSignature_Scalar::clear_final_variable_behavior() {
// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Scalar)
  switch (final_variable_behavior_case()) {
    case kVariadic: {
      if (GetArenaForAllocation() == nullptr) {
        delete final_variable_behavior_.variadic_;
      }
      break;
    }
    case kNormal: {
      if (GetArenaForAllocation() == nullptr) {
        delete final_variable_behavior_.normal_;
      }
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
}


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

  arguments_.Clear();
  name_.Clear();
  implementations_.Clear();
  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
    delete description_;
  }
  description_ = nullptr;
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
  ::memset(&deterministic_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&session_dependent_) -
      reinterpret_cast<char*>(&deterministic_)) + sizeof(session_dependent_));
  clear_final_variable_behavior();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionSignature_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) {
      // repeated .substrait.FunctionSignature.Argument arguments = 2 [json_name = "arguments"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          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<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // repeated string name = 3 [json_name = "name"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_name();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Scalar.name"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_description(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool deterministic = 7 [json_name = "deterministic"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool session_dependent = 8 [json_name = "sessionDependent"];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression output_type = 9 [json_name = "outputType"];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.FunctionSignature.Implementation implementations = 12 [json_name = "implementations"];
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_implementations(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(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* FunctionSignature_Scalar::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Scalar)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.FunctionSignature.Argument arguments = 2 [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(2, this->_internal_arguments(i), target, stream);
  }

  // repeated string name = 3 [json_name = "name"];
  for (int i = 0, n = this->_internal_name_size(); i < n; i++) {
    const auto& s = this->_internal_name(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.FunctionSignature.Scalar.name");
    target = stream->WriteString(3, s, target);
  }

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

  // bool deterministic = 7 [json_name = "deterministic"];
  if (this->_internal_deterministic() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target);
  }

  // bool session_dependent = 8 [json_name = "sessionDependent"];
  if (this->_internal_session_dependent() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target);
  }

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

  // .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
  if (_internal_has_variadic()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::variadic(this), target, stream);
  }

  // .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
  if (_internal_has_normal()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::normal(this), target, stream);
  }

  // repeated .substrait.FunctionSignature.Implementation implementations = 12 [json_name = "implementations"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_implementations_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(12, this->_internal_implementations(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.FunctionSignature.Scalar)
  return target;
}

size_t FunctionSignature_Scalar::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.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;

  // repeated .substrait.FunctionSignature.Argument arguments = 2 [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);
  }

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

  // repeated .substrait.FunctionSignature.Implementation implementations = 12 [json_name = "implementations"];
  total_size += 1UL * this->_internal_implementations_size();
  for (const auto& msg : this->implementations_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
  if (this->_internal_has_description()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *description_);
  }

  // .substrait.DerivationExpression output_type = 9 [json_name = "outputType"];
  if (this->_internal_has_output_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *output_type_);
  }

  // bool deterministic = 7 [json_name = "deterministic"];
  if (this->_internal_deterministic() != 0) {
    total_size += 1 + 1;
  }

  // bool session_dependent = 8 [json_name = "sessionDependent"];
  if (this->_internal_session_dependent() != 0) {
    total_size += 1 + 1;
  }

  switch (final_variable_behavior_case()) {
    // .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
    case kVariadic: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *final_variable_behavior_.variadic_);
      break;
    }
    // .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
    case kNormal: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *final_variable_behavior_.normal_);
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  arguments_.MergeFrom(from.arguments_);
  name_.MergeFrom(from.name_);
  implementations_.MergeFrom(from.implementations_);
  if (from._internal_has_description()) {
    _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description());
  }
  if (from._internal_has_output_type()) {
    _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type());
  }
  if (from._internal_deterministic() != 0) {
    _internal_set_deterministic(from._internal_deterministic());
  }
  if (from._internal_session_dependent() != 0) {
    _internal_set_session_dependent(from._internal_session_dependent());
  }
  switch (from.final_variable_behavior_case()) {
    case kVariadic: {
      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
      break;
    }
    case kNormal: {
      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void FunctionSignature_Scalar::InternalSwap(FunctionSignature_Scalar* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  arguments_.InternalSwap(&other->arguments_);
  name_.InternalSwap(&other->name_);
  implementations_.InternalSwap(&other->implementations_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, session_dependent_)
      + sizeof(FunctionSignature_Scalar::session_dependent_)
      - PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, description_)>(
          reinterpret_cast<char*>(&description_),
          reinterpret_cast<char*>(&other->description_));
  swap(final_variable_behavior_, other->final_variable_behavior_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Scalar::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[2]);
}

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

class FunctionSignature_Aggregate::_Internal {
 public:
  static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Aggregate* msg);
  static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Aggregate* msg);
  static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Aggregate* msg);
  static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Aggregate* msg);
  static const ::substrait::Type& intermediate_type(const FunctionSignature_Aggregate* msg);
};

const ::substrait::FunctionSignature_Description&
FunctionSignature_Aggregate::_Internal::description(const FunctionSignature_Aggregate* msg) {
  return *msg->description_;
}
const ::substrait::DerivationExpression&
FunctionSignature_Aggregate::_Internal::output_type(const FunctionSignature_Aggregate* msg) {
  return *msg->output_type_;
}
const ::substrait::FunctionSignature_FinalArgVariadic&
FunctionSignature_Aggregate::_Internal::variadic(const FunctionSignature_Aggregate* msg) {
  return *msg->final_variable_behavior_.variadic_;
}
const ::substrait::FunctionSignature_FinalArgNormal&
FunctionSignature_Aggregate::_Internal::normal(const FunctionSignature_Aggregate* msg) {
  return *msg->final_variable_behavior_.normal_;
}
const ::substrait::Type&
FunctionSignature_Aggregate::_Internal::intermediate_type(const FunctionSignature_Aggregate* msg) {
  return *msg->intermediate_type_;
}
void FunctionSignature_Aggregate::clear_output_type() {
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
}
void FunctionSignature_Aggregate::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_final_variable_behavior();
  if (variadic) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic);
    if (message_arena != submessage_arena) {
      variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, variadic, submessage_arena);
    }
    set_has_variadic();
    final_variable_behavior_.variadic_ = variadic;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.variadic)
}
void FunctionSignature_Aggregate::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_final_variable_behavior();
  if (normal) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal);
    if (message_arena != submessage_arena) {
      normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, normal, submessage_arena);
    }
    set_has_normal();
    final_variable_behavior_.normal_ = normal;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.normal)
}
void FunctionSignature_Aggregate::clear_intermediate_type() {
  if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) {
    delete intermediate_type_;
  }
  intermediate_type_ = nullptr;
}
FunctionSignature_Aggregate::FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  arguments_(arena),
  implementations_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Aggregate)
}
FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      arguments_(from.arguments_),
      implementations_(from.implementations_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_name().empty()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_description()) {
    description_ = new ::substrait::FunctionSignature_Description(*from.description_);
  } else {
    description_ = nullptr;
  }
  if (from._internal_has_output_type()) {
    output_type_ = new ::substrait::DerivationExpression(*from.output_type_);
  } else {
    output_type_ = nullptr;
  }
  if (from._internal_has_intermediate_type()) {
    intermediate_type_ = new ::substrait::Type(*from.intermediate_type_);
  } else {
    intermediate_type_ = nullptr;
  }
  ::memcpy(&deterministic_, &from.deterministic_,
    static_cast<size_t>(reinterpret_cast<char*>(&max_set_) -
    reinterpret_cast<char*>(&deterministic_)) + sizeof(max_set_));
  clear_has_final_variable_behavior();
  switch (from.final_variable_behavior_case()) {
    case kVariadic: {
      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
      break;
    }
    case kNormal: {
      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Aggregate)
}

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

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

inline void FunctionSignature_Aggregate::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete description_;
  if (this != internal_default_instance()) delete output_type_;
  if (this != internal_default_instance()) delete intermediate_type_;
  if (has_final_variable_behavior()) {
    clear_final_variable_behavior();
  }
}

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

void FunctionSignature_Aggregate::clear_final_variable_behavior() {
// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Aggregate)
  switch (final_variable_behavior_case()) {
    case kVariadic: {
      if (GetArenaForAllocation() == nullptr) {
        delete final_variable_behavior_.variadic_;
      }
      break;
    }
    case kNormal: {
      if (GetArenaForAllocation() == nullptr) {
        delete final_variable_behavior_.normal_;
      }
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
}


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

  arguments_.Clear();
  implementations_.Clear();
  name_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
    delete description_;
  }
  description_ = nullptr;
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
  if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) {
    delete intermediate_type_;
  }
  intermediate_type_ = nullptr;
  ::memset(&deterministic_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&max_set_) -
      reinterpret_cast<char*>(&deterministic_)) + sizeof(max_set_));
  clear_final_variable_behavior();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionSignature_Aggregate::_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.FunctionSignature.Argument arguments = 2 [json_name = "arguments"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          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<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // string name = 3 [json_name = "name"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Aggregate.name"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_description(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool deterministic = 7 [json_name = "deterministic"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool session_dependent = 8 [json_name = "sessionDependent"];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression output_type = 9 [json_name = "outputType"];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 max_set = 12 [json_name = "maxSet"];
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
          max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.Type intermediate_type = 13 [json_name = "intermediateType"];
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool ordered = 14 [json_name = "ordered"];
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
          ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_implementations(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(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* FunctionSignature_Aggregate::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Aggregate)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.FunctionSignature.Argument arguments = 2 [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(2, this->_internal_arguments(i), target, stream);
  }

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

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

  // bool deterministic = 7 [json_name = "deterministic"];
  if (this->_internal_deterministic() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target);
  }

  // bool session_dependent = 8 [json_name = "sessionDependent"];
  if (this->_internal_session_dependent() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target);
  }

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

  // .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
  if (_internal_has_variadic()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::variadic(this), target, stream);
  }

  // .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
  if (_internal_has_normal()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::normal(this), target, stream);
  }

  // uint64 max_set = 12 [json_name = "maxSet"];
  if (this->_internal_max_set() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target);
  }

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

  // bool ordered = 14 [json_name = "ordered"];
  if (this->_internal_ordered() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(14, this->_internal_ordered(), target);
  }

  // repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_implementations_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(15, this->_internal_implementations(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.FunctionSignature.Aggregate)
  return target;
}

size_t FunctionSignature_Aggregate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Aggregate)
  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.FunctionSignature.Argument arguments = 2 [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);
  }

  // repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
  total_size += 1UL * this->_internal_implementations_size();
  for (const auto& msg : this->implementations_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

  // .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
  if (this->_internal_has_description()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *description_);
  }

  // .substrait.DerivationExpression output_type = 9 [json_name = "outputType"];
  if (this->_internal_has_output_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *output_type_);
  }

  // .substrait.Type intermediate_type = 13 [json_name = "intermediateType"];
  if (this->_internal_has_intermediate_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *intermediate_type_);
  }

  // bool deterministic = 7 [json_name = "deterministic"];
  if (this->_internal_deterministic() != 0) {
    total_size += 1 + 1;
  }

  // bool session_dependent = 8 [json_name = "sessionDependent"];
  if (this->_internal_session_dependent() != 0) {
    total_size += 1 + 1;
  }

  // bool ordered = 14 [json_name = "ordered"];
  if (this->_internal_ordered() != 0) {
    total_size += 1 + 1;
  }

  // uint64 max_set = 12 [json_name = "maxSet"];
  if (this->_internal_max_set() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_max_set());
  }

  switch (final_variable_behavior_case()) {
    // .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
    case kVariadic: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *final_variable_behavior_.variadic_);
      break;
    }
    // .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
    case kNormal: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *final_variable_behavior_.normal_);
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  arguments_.MergeFrom(from.arguments_);
  implementations_.MergeFrom(from.implementations_);
  if (!from._internal_name().empty()) {
    _internal_set_name(from._internal_name());
  }
  if (from._internal_has_description()) {
    _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description());
  }
  if (from._internal_has_output_type()) {
    _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type());
  }
  if (from._internal_has_intermediate_type()) {
    _internal_mutable_intermediate_type()->::substrait::Type::MergeFrom(from._internal_intermediate_type());
  }
  if (from._internal_deterministic() != 0) {
    _internal_set_deterministic(from._internal_deterministic());
  }
  if (from._internal_session_dependent() != 0) {
    _internal_set_session_dependent(from._internal_session_dependent());
  }
  if (from._internal_ordered() != 0) {
    _internal_set_ordered(from._internal_ordered());
  }
  if (from._internal_max_set() != 0) {
    _internal_set_max_set(from._internal_max_set());
  }
  switch (from.final_variable_behavior_case()) {
    case kVariadic: {
      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
      break;
    }
    case kNormal: {
      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void FunctionSignature_Aggregate::InternalSwap(FunctionSignature_Aggregate* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  arguments_.InternalSwap(&other->arguments_);
  implementations_.InternalSwap(&other->implementations_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &name_, lhs_arena,
      &other->name_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, max_set_)
      + sizeof(FunctionSignature_Aggregate::max_set_)
      - PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, description_)>(
          reinterpret_cast<char*>(&description_),
          reinterpret_cast<char*>(&other->description_));
  swap(final_variable_behavior_, other->final_variable_behavior_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Aggregate::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[3]);
}

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

class FunctionSignature_Window::_Internal {
 public:
  static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Window* msg);
  static const ::substrait::DerivationExpression& intermediate_type(const FunctionSignature_Window* msg);
  static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Window* msg);
  static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Window* msg);
  static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Window* msg);
};

const ::substrait::FunctionSignature_Description&
FunctionSignature_Window::_Internal::description(const FunctionSignature_Window* msg) {
  return *msg->description_;
}
const ::substrait::DerivationExpression&
FunctionSignature_Window::_Internal::intermediate_type(const FunctionSignature_Window* msg) {
  return *msg->intermediate_type_;
}
const ::substrait::DerivationExpression&
FunctionSignature_Window::_Internal::output_type(const FunctionSignature_Window* msg) {
  return *msg->output_type_;
}
const ::substrait::FunctionSignature_FinalArgVariadic&
FunctionSignature_Window::_Internal::variadic(const FunctionSignature_Window* msg) {
  return *msg->final_variable_behavior_.variadic_;
}
const ::substrait::FunctionSignature_FinalArgNormal&
FunctionSignature_Window::_Internal::normal(const FunctionSignature_Window* msg) {
  return *msg->final_variable_behavior_.normal_;
}
void FunctionSignature_Window::clear_intermediate_type() {
  if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) {
    delete intermediate_type_;
  }
  intermediate_type_ = nullptr;
}
void FunctionSignature_Window::clear_output_type() {
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
}
void FunctionSignature_Window::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_final_variable_behavior();
  if (variadic) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic);
    if (message_arena != submessage_arena) {
      variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, variadic, submessage_arena);
    }
    set_has_variadic();
    final_variable_behavior_.variadic_ = variadic;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.variadic)
}
void FunctionSignature_Window::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_final_variable_behavior();
  if (normal) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal);
    if (message_arena != submessage_arena) {
      normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, normal, submessage_arena);
    }
    set_has_normal();
    final_variable_behavior_.normal_ = normal;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.normal)
}
FunctionSignature_Window::FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  arguments_(arena),
  name_(arena),
  implementations_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Window)
}
FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Window& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      arguments_(from.arguments_),
      name_(from.name_),
      implementations_(from.implementations_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_description()) {
    description_ = new ::substrait::FunctionSignature_Description(*from.description_);
  } else {
    description_ = nullptr;
  }
  if (from._internal_has_intermediate_type()) {
    intermediate_type_ = new ::substrait::DerivationExpression(*from.intermediate_type_);
  } else {
    intermediate_type_ = nullptr;
  }
  if (from._internal_has_output_type()) {
    output_type_ = new ::substrait::DerivationExpression(*from.output_type_);
  } else {
    output_type_ = nullptr;
  }
  ::memcpy(&deterministic_, &from.deterministic_,
    static_cast<size_t>(reinterpret_cast<char*>(&max_set_) -
    reinterpret_cast<char*>(&deterministic_)) + sizeof(max_set_));
  clear_has_final_variable_behavior();
  switch (from.final_variable_behavior_case()) {
    case kVariadic: {
      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
      break;
    }
    case kNormal: {
      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Window)
}

inline void FunctionSignature_Window::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&description_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&max_set_) -
    reinterpret_cast<char*>(&description_)) + sizeof(max_set_));
clear_has_final_variable_behavior();
}

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

inline void FunctionSignature_Window::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete description_;
  if (this != internal_default_instance()) delete intermediate_type_;
  if (this != internal_default_instance()) delete output_type_;
  if (has_final_variable_behavior()) {
    clear_final_variable_behavior();
  }
}

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

void FunctionSignature_Window::clear_final_variable_behavior() {
// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Window)
  switch (final_variable_behavior_case()) {
    case kVariadic: {
      if (GetArenaForAllocation() == nullptr) {
        delete final_variable_behavior_.variadic_;
      }
      break;
    }
    case kNormal: {
      if (GetArenaForAllocation() == nullptr) {
        delete final_variable_behavior_.normal_;
      }
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
}


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

  arguments_.Clear();
  name_.Clear();
  implementations_.Clear();
  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
    delete description_;
  }
  description_ = nullptr;
  if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) {
    delete intermediate_type_;
  }
  intermediate_type_ = nullptr;
  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
    delete output_type_;
  }
  output_type_ = nullptr;
  ::memset(&deterministic_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&max_set_) -
      reinterpret_cast<char*>(&deterministic_)) + sizeof(max_set_));
  clear_final_variable_behavior();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionSignature_Window::_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.FunctionSignature.Argument arguments = 2 [json_name = "arguments"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          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<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      // repeated string name = 3 [json_name = "name"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_name();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Window.name"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_description(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool deterministic = 7 [json_name = "deterministic"];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool session_dependent = 8 [json_name = "sessionDependent"];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression intermediate_type = 9 [json_name = "intermediateType"];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.DerivationExpression output_type = 10 [json_name = "outputType"];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool ordered = 11 [json_name = "ordered"];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
          ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // uint64 max_set = 12 [json_name = "maxSet"];
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
          max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.Window.WindowType window_type = 14 [json_name = "windowType"];
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_window_type(static_cast<::substrait::FunctionSignature_Window_WindowType>(val));
        } else
          goto handle_unusual;
        continue;
      // repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_implementations(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.FinalArgVariadic variadic = 16 [json_name = "variadic"];
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
          ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.FinalArgNormal normal = 17 [json_name = "normal"];
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
          ptr = ctx->ParseMessage(_internal_mutable_normal(), 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* FunctionSignature_Window::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Window)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .substrait.FunctionSignature.Argument arguments = 2 [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(2, this->_internal_arguments(i), target, stream);
  }

  // repeated string name = 3 [json_name = "name"];
  for (int i = 0, n = this->_internal_name_size(); i < n; i++) {
    const auto& s = this->_internal_name(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.FunctionSignature.Window.name");
    target = stream->WriteString(3, s, target);
  }

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

  // bool deterministic = 7 [json_name = "deterministic"];
  if (this->_internal_deterministic() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target);
  }

  // bool session_dependent = 8 [json_name = "sessionDependent"];
  if (this->_internal_session_dependent() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target);
  }

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

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

  // bool ordered = 11 [json_name = "ordered"];
  if (this->_internal_ordered() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_ordered(), target);
  }

  // uint64 max_set = 12 [json_name = "maxSet"];
  if (this->_internal_max_set() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target);
  }

  // .substrait.FunctionSignature.Window.WindowType window_type = 14 [json_name = "windowType"];
  if (this->_internal_window_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      14, this->_internal_window_type(), target);
  }

  // repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_implementations_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(15, this->_internal_implementations(i), target, stream);
  }

  // .substrait.FunctionSignature.FinalArgVariadic variadic = 16 [json_name = "variadic"];
  if (_internal_has_variadic()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        16, _Internal::variadic(this), target, stream);
  }

  // .substrait.FunctionSignature.FinalArgNormal normal = 17 [json_name = "normal"];
  if (_internal_has_normal()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        17, _Internal::normal(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.FunctionSignature.Window)
  return target;
}

size_t FunctionSignature_Window::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Window)
  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.FunctionSignature.Argument arguments = 2 [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);
  }

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

  // repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
  total_size += 1UL * this->_internal_implementations_size();
  for (const auto& msg : this->implementations_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
  if (this->_internal_has_description()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *description_);
  }

  // .substrait.DerivationExpression intermediate_type = 9 [json_name = "intermediateType"];
  if (this->_internal_has_intermediate_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *intermediate_type_);
  }

  // .substrait.DerivationExpression output_type = 10 [json_name = "outputType"];
  if (this->_internal_has_output_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *output_type_);
  }

  // bool deterministic = 7 [json_name = "deterministic"];
  if (this->_internal_deterministic() != 0) {
    total_size += 1 + 1;
  }

  // bool session_dependent = 8 [json_name = "sessionDependent"];
  if (this->_internal_session_dependent() != 0) {
    total_size += 1 + 1;
  }

  // bool ordered = 11 [json_name = "ordered"];
  if (this->_internal_ordered() != 0) {
    total_size += 1 + 1;
  }

  // .substrait.FunctionSignature.Window.WindowType window_type = 14 [json_name = "windowType"];
  if (this->_internal_window_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_window_type());
  }

  // uint64 max_set = 12 [json_name = "maxSet"];
  if (this->_internal_max_set() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_max_set());
  }

  switch (final_variable_behavior_case()) {
    // .substrait.FunctionSignature.FinalArgVariadic variadic = 16 [json_name = "variadic"];
    case kVariadic: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *final_variable_behavior_.variadic_);
      break;
    }
    // .substrait.FunctionSignature.FinalArgNormal normal = 17 [json_name = "normal"];
    case kNormal: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *final_variable_behavior_.normal_);
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  arguments_.MergeFrom(from.arguments_);
  name_.MergeFrom(from.name_);
  implementations_.MergeFrom(from.implementations_);
  if (from._internal_has_description()) {
    _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description());
  }
  if (from._internal_has_intermediate_type()) {
    _internal_mutable_intermediate_type()->::substrait::DerivationExpression::MergeFrom(from._internal_intermediate_type());
  }
  if (from._internal_has_output_type()) {
    _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type());
  }
  if (from._internal_deterministic() != 0) {
    _internal_set_deterministic(from._internal_deterministic());
  }
  if (from._internal_session_dependent() != 0) {
    _internal_set_session_dependent(from._internal_session_dependent());
  }
  if (from._internal_ordered() != 0) {
    _internal_set_ordered(from._internal_ordered());
  }
  if (from._internal_window_type() != 0) {
    _internal_set_window_type(from._internal_window_type());
  }
  if (from._internal_max_set() != 0) {
    _internal_set_max_set(from._internal_max_set());
  }
  switch (from.final_variable_behavior_case()) {
    case kVariadic: {
      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
      break;
    }
    case kNormal: {
      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
      break;
    }
    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void FunctionSignature_Window::InternalSwap(FunctionSignature_Window* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  arguments_.InternalSwap(&other->arguments_);
  name_.InternalSwap(&other->name_);
  implementations_.InternalSwap(&other->implementations_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, max_set_)
      + sizeof(FunctionSignature_Window::max_set_)
      - PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, description_)>(
          reinterpret_cast<char*>(&description_),
          reinterpret_cast<char*>(&other->description_));
  swap(final_variable_behavior_, other->final_variable_behavior_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Window::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[4]);
}

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

class FunctionSignature_Description::_Internal {
 public:
};

FunctionSignature_Description::FunctionSignature_Description(::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.FunctionSignature.Description)
}
FunctionSignature_Description::FunctionSignature_Description(const FunctionSignature_Description& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_language().empty()) {
    language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_language(), 
      GetArenaForAllocation());
  }
  body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_body().empty()) {
    body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_body(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Description)
}

inline void FunctionSignature_Description::SharedCtor() {
language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void FunctionSignature_Description::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  language_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  body_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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

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

  language_.ClearToEmpty();
  body_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionSignature_Description::_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 language = 1 [json_name = "language"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_language();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.language"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string body = 2 [json_name = "body"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_body();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.body"));
          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* FunctionSignature_Description::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Description)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // string body = 2 [json_name = "body"];
  if (!this->_internal_body().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_body().data(), static_cast<int>(this->_internal_body().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.FunctionSignature.Description.body");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_body(), 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.FunctionSignature.Description)
  return target;
}

size_t FunctionSignature_Description::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Description)
  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 language = 1 [json_name = "language"];
  if (!this->_internal_language().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_language());
  }

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

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (!from._internal_language().empty()) {
    _internal_set_language(from._internal_language());
  }
  if (!from._internal_body().empty()) {
    _internal_set_body(from._internal_body());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void FunctionSignature_Description::InternalSwap(FunctionSignature_Description* 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(),
      &language_, lhs_arena,
      &other->language_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &body_, lhs_arena,
      &other->body_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Description::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[5]);
}

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

class FunctionSignature_Implementation::_Internal {
 public:
};

FunctionSignature_Implementation::FunctionSignature_Implementation(::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.FunctionSignature.Implementation)
}
FunctionSignature_Implementation::FunctionSignature_Implementation(const FunctionSignature_Implementation& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_uri().empty()) {
    uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), 
      GetArenaForAllocation());
  }
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Implementation)
}

inline void FunctionSignature_Implementation::SharedCtor() {
uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
type_ = 0;
}

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

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

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

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

  uri_.ClearToEmpty();
  type_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionSignature_Implementation::_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.FunctionSignature.Implementation.Type type = 1 [json_name = "type"];
      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_type(static_cast<::substrait::FunctionSignature_Implementation_Type>(val));
        } else
          goto handle_unusual;
        continue;
      // string uri = 2 [json_name = "uri"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_uri();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Implementation.uri"));
          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* FunctionSignature_Implementation::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Implementation)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // string uri = 2 [json_name = "uri"];
  if (!this->_internal_uri().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_uri().data(), static_cast<int>(this->_internal_uri().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.FunctionSignature.Implementation.uri");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_uri(), 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.FunctionSignature.Implementation)
  return target;
}

size_t FunctionSignature_Implementation::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Implementation)
  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 uri = 2 [json_name = "uri"];
  if (!this->_internal_uri().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_uri());
  }

  // .substrait.FunctionSignature.Implementation.Type type = 1 [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 FunctionSignature_Implementation::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    FunctionSignature_Implementation::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Implementation::GetClassData() const { return &_class_data_; }

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


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

  if (!from._internal_uri().empty()) {
    _internal_set_uri(from._internal_uri());
  }
  if (from._internal_type() != 0) {
    _internal_set_type(from._internal_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void FunctionSignature_Implementation::InternalSwap(FunctionSignature_Implementation* 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(),
      &uri_, lhs_arena,
      &other->uri_, rhs_arena
  );
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Implementation::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[6]);
}

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

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

const ::substrait::ParameterizedType&
FunctionSignature_Argument_ValueArgument::_Internal::type(const FunctionSignature_Argument_ValueArgument* msg) {
  return *msg->type_;
}
void FunctionSignature_Argument_ValueArgument::clear_type() {
  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
    delete type_;
  }
  type_ = nullptr;
}
FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(::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.FunctionSignature.Argument.ValueArgument)
}
FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_type()) {
    type_ = new ::substrait::ParameterizedType(*from.type_);
  } else {
    type_ = nullptr;
  }
  constant_ = from.constant_;
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.ValueArgument)
}

inline void FunctionSignature_Argument_ValueArgument::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*>(&constant_) -
    reinterpret_cast<char*>(&type_)) + sizeof(constant_));
}

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

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

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

void FunctionSignature_Argument_ValueArgument::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.ValueArgument)
  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;
  constant_ = false;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionSignature_Argument_ValueArgument::_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.ParameterizedType 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;
      // bool constant = 2 [json_name = "constant"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          constant_ = ::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* FunctionSignature_Argument_ValueArgument::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.ValueArgument)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // bool constant = 2 [json_name = "constant"];
  if (this->_internal_constant() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_constant(), 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.FunctionSignature.Argument.ValueArgument)
  return target;
}

size_t FunctionSignature_Argument_ValueArgument::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.ValueArgument)
  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.ParameterizedType type = 1 [json_name = "type"];
  if (this->_internal_has_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *type_);
  }

  // bool constant = 2 [json_name = "constant"];
  if (this->_internal_constant() != 0) {
    total_size += 1 + 1;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_type()) {
    _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type());
  }
  if (from._internal_constant() != 0) {
    _internal_set_constant(from._internal_constant());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_ValueArgument::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[7]);
}

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

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

const ::substrait::ParameterizedType&
FunctionSignature_Argument_TypeArgument::_Internal::type(const FunctionSignature_Argument_TypeArgument* msg) {
  return *msg->type_;
}
void FunctionSignature_Argument_TypeArgument::clear_type() {
  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
    delete type_;
  }
  type_ = nullptr;
}
FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(::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.FunctionSignature.Argument.TypeArgument)
}
FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_type()) {
    type_ = new ::substrait::ParameterizedType(*from.type_);
  } else {
    type_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.TypeArgument)
}

inline void FunctionSignature_Argument_TypeArgument::SharedCtor() {
type_ = nullptr;
}

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

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

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

void FunctionSignature_Argument_TypeArgument::Clear() {
// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.TypeArgument)
  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;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionSignature_Argument_TypeArgument::_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.ParameterizedType 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;
      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* FunctionSignature_Argument_TypeArgument::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.TypeArgument)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  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.FunctionSignature.Argument.TypeArgument)
  return target;
}

size_t FunctionSignature_Argument_TypeArgument::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.TypeArgument)
  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.ParameterizedType type = 1 [json_name = "type"];
  if (this->_internal_has_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *type_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (from._internal_has_type()) {
    _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

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

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_TypeArgument::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[8]);
}

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

class FunctionSignature_Argument_EnumArgument::_Internal {
 public:
};

FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(::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.FunctionSignature.Argument.EnumArgument)
}
FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      options_(from.options_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  optional_ = from.optional_;
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.EnumArgument)
}

inline void FunctionSignature_Argument_EnumArgument::SharedCtor() {
optional_ = false;
}

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

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

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

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

  options_.Clear();
  optional_ = false;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionSignature_Argument_EnumArgument::_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 options = 1 [json_name = "options"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_options();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Argument.EnumArgument.options"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      // bool optional = 2 [json_name = "optional"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          optional_ = ::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* FunctionSignature_Argument_EnumArgument::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.EnumArgument)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string options = 1 [json_name = "options"];
  for (int i = 0, n = this->_internal_options_size(); i < n; i++) {
    const auto& s = this->_internal_options(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "substrait.FunctionSignature.Argument.EnumArgument.options");
    target = stream->WriteString(1, s, target);
  }

  // bool optional = 2 [json_name = "optional"];
  if (this->_internal_optional() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_optional(), 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.FunctionSignature.Argument.EnumArgument)
  return target;
}

size_t FunctionSignature_Argument_EnumArgument::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.EnumArgument)
  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 options = 1 [json_name = "options"];
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(options_.size());
  for (int i = 0, n = options_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      options_.Get(i));
  }

  // bool optional = 2 [json_name = "optional"];
  if (this->_internal_optional() != 0) {
    total_size += 1 + 1;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  options_.MergeFrom(from.options_);
  if (from._internal_optional() != 0) {
    _internal_set_optional(from._internal_optional());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void FunctionSignature_Argument_EnumArgument::InternalSwap(FunctionSignature_Argument_EnumArgument* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  options_.InternalSwap(&other->options_);
  swap(optional_, other->optional_);
}

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_EnumArgument::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[9]);
}

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

class FunctionSignature_Argument::_Internal {
 public:
  static const ::substrait::FunctionSignature_Argument_ValueArgument& value(const FunctionSignature_Argument* msg);
  static const ::substrait::FunctionSignature_Argument_TypeArgument& type(const FunctionSignature_Argument* msg);
  static const ::substrait::FunctionSignature_Argument_EnumArgument& enum_(const FunctionSignature_Argument* msg);
};

const ::substrait::FunctionSignature_Argument_ValueArgument&
FunctionSignature_Argument::_Internal::value(const FunctionSignature_Argument* msg) {
  return *msg->argument_kind_.value_;
}
const ::substrait::FunctionSignature_Argument_TypeArgument&
FunctionSignature_Argument::_Internal::type(const FunctionSignature_Argument* msg) {
  return *msg->argument_kind_.type_;
}
const ::substrait::FunctionSignature_Argument_EnumArgument&
FunctionSignature_Argument::_Internal::enum_(const FunctionSignature_Argument* msg) {
  return *msg->argument_kind_.enum__;
}
void FunctionSignature_Argument::set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_argument_kind();
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_ValueArgument>::GetOwningArena(value);
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    set_has_value();
    argument_kind_.value_ = value;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.value)
}
void FunctionSignature_Argument::set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_argument_kind();
  if (type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_TypeArgument>::GetOwningArena(type);
    if (message_arena != submessage_arena) {
      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type, submessage_arena);
    }
    set_has_type();
    argument_kind_.type_ = type;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.type)
}
void FunctionSignature_Argument::set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_argument_kind();
  if (enum_) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_EnumArgument>::GetOwningArena(enum_);
    if (message_arena != submessage_arena) {
      enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, enum_, submessage_arena);
    }
    set_has_enum_();
    argument_kind_.enum__ = enum_;
  }
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.enum)
}
FunctionSignature_Argument::FunctionSignature_Argument(::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.FunctionSignature.Argument)
}
FunctionSignature_Argument::FunctionSignature_Argument(const FunctionSignature_Argument& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_name().empty()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArenaForAllocation());
  }
  clear_has_argument_kind();
  switch (from.argument_kind_case()) {
    case kValue: {
      _internal_mutable_value()->::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value());
      break;
    }
    case kType: {
      _internal_mutable_type()->::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type());
      break;
    }
    case kEnum: {
      _internal_mutable_enum_()->::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_());
      break;
    }
    case ARGUMENT_KIND_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument)
}

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

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

inline void FunctionSignature_Argument::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (has_argument_kind()) {
    clear_argument_kind();
  }
}

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

void FunctionSignature_Argument::clear_argument_kind() {
// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Argument)
  switch (argument_kind_case()) {
    case kValue: {
      if (GetArenaForAllocation() == nullptr) {
        delete argument_kind_.value_;
      }
      break;
    }
    case kType: {
      if (GetArenaForAllocation() == nullptr) {
        delete argument_kind_.type_;
      }
      break;
    }
    case kEnum: {
      if (GetArenaForAllocation() == nullptr) {
        delete argument_kind_.enum__;
      }
      break;
    }
    case ARGUMENT_KIND_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = ARGUMENT_KIND_NOT_SET;
}


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

  name_.ClearToEmpty();
  clear_argument_kind();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionSignature_Argument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string name = 1 [json_name = "name"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Argument.name"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.Argument.ValueArgument 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;
      // .substrait.FunctionSignature.Argument.TypeArgument type = 3 [json_name = "type"];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .substrait.FunctionSignature.Argument.EnumArgument enum = 4 [json_name = "enum"];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_enum_(), 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* FunctionSignature_Argument::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  // .substrait.FunctionSignature.Argument.EnumArgument enum = 4 [json_name = "enum"];
  if (_internal_has_enum_()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::enum_(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.FunctionSignature.Argument)
  return target;
}

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

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

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

  switch (argument_kind_case()) {
    // .substrait.FunctionSignature.Argument.ValueArgument value = 2 [json_name = "value"];
    case kValue: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *argument_kind_.value_);
      break;
    }
    // .substrait.FunctionSignature.Argument.TypeArgument type = 3 [json_name = "type"];
    case kType: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *argument_kind_.type_);
      break;
    }
    // .substrait.FunctionSignature.Argument.EnumArgument enum = 4 [json_name = "enum"];
    case kEnum: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *argument_kind_.enum__);
      break;
    }
    case ARGUMENT_KIND_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

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

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


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

  if (!from._internal_name().empty()) {
    _internal_set_name(from._internal_name());
  }
  switch (from.argument_kind_case()) {
    case kValue: {
      _internal_mutable_value()->::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value());
      break;
    }
    case kType: {
      _internal_mutable_type()->::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type());
      break;
    }
    case kEnum: {
      _internal_mutable_enum_()->::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_());
      break;
    }
    case ARGUMENT_KIND_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void FunctionSignature_Argument::InternalSwap(FunctionSignature_Argument* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &name_, lhs_arena,
      &other->name_, rhs_arena
  );
  swap(argument_kind_, other->argument_kind_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[10]);
}

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

class FunctionSignature::_Internal {
 public:
};

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





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







::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
      file_level_metadata_substrait_2ffunction_2eproto[11]);
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace substrait
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_FinalArgVariadic >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_FinalArgNormal >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Scalar >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Scalar >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Aggregate >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Aggregate >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Window >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Window >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Description >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Description >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Implementation >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Implementation >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_ValueArgument >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_TypeArgument >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_EnumArgument >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument >(arena);
}
template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature* Arena::CreateMaybeMessage< ::substrait::FunctionSignature >(Arena* arena) {
  return Arena::CreateMessageInternal< ::substrait::FunctionSignature >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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